/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('qualitycheck', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model BusinessCategoryBasicInfo {
  bid?: int32(name='Bid'),
  name?: string(name='Name'),
  originalId?: long(name='OriginalId'),
  serviceType?: int32(name='ServiceType'),
}

model ConditionBasicInfo {
  checkRange?: {
    absolute?: boolean(name='Absolute'),
    allSentencesSatisfy?: boolean(name='AllSentencesSatisfy'),
    anchor?: {
      cid?: string(name='Cid'),
      hitTime?: int32(name='Hit_time'),
      location?: string(name='Location'),
    }(name='Anchor'),
    range?: {
      from?: int32(name='From'),
      to?: int32(name='To'),
    }(name='Range'),
    role?: string(name='Role'),
    roleId?: int32(name='RoleId'),
  }(name='Check_range'),
  cid?: string(name='Cid'),
  exclusion?: int32(name='Exclusion'),
  id?: long(name='Id'),
  lambda?: string(name='Lambda'),
  name?: string(name='Name'),
  operators?: [
    OperatorBasicInfo
  ](name='Operators'),
  rid?: string(name='Rid'),
  userGroup?: string(name='UserGroup'),
}

model GraphFlowNode {
  conditions?: [
    ConditionBasicInfo
  ](name='Conditions'),
  content?: string(name='Content'),
  id?: long(name='Id'),
  index?: int32(name='Index'),
  name?: string(name='Name'),
  nextNodes?: [ 
    {
      checkType?: int32(name='CheckType'),
      index?: int32(name='Index'),
      lambda?: string(name='Lambda'),
      name?: string(name='Name'),
      nextNodeId?: long(name='NextNodeId'),
      triggers?: [ string ](name='Triggers'),
    }
  ](name='NextNodes'),
  nodeType?: string(name='NodeType'),
  properties?: {
    autoReview?: int32(name='AutoReview'),
    branchJudge?: boolean(name='BranchJudge'),
    checkMoreSize?: int32(name='CheckMoreSize'),
    checkType?: int32(name='CheckType'),
    lambda?: string(name='Lambda'),
    role?: string(name='Role'),
    ruleScoreType?: int32(name='RuleScoreType'),
    sayType?: string(name='SayType'),
    scoreNum?: int32(name='ScoreNum'),
    scoreNumType?: int32(name='ScoreNumType'),
    scoreRuleHitType?: int32(name='ScoreRuleHitType'),
    scoreType?: int32(name='ScoreType'),
    triggers?: [ string ](name='Triggers'),
    type?: string(name='Type'),
  }(name='Properties'),
  rid?: long(name='Rid'),
  useConditions?: boolean(name='UseConditions'),
}

model JudgeNodeMetaDesc {
  actualValue?: string(name='ActualValue'),
  dataType?: int32(name='DataType'),
  field?: string(name='Field'),
  fieldType?: int32(name='FieldType'),
  symbol?: int32(name='Symbol'),
  value?: string(name='Value'),
}

model NextNodeSituations {
  conditionGroup?: [ 
    {
      conditions?: [
        JudgeNodeMetaDesc
      ](name='Conditions'),
      type?: string(name='Type'),
    }
  ](name='ConditionGroup'),
  type?: string(name='Type'),
}

model OperatorBasicInfo {
  id?: long(name='Id'),
  name?: string(name='Name'),
  oid?: string(name='Oid'),
  param?: {
    answerThreshold?: string(name='AnswerThreshold'),
    antModelInfo?: map[string]string(name='AntModelInfo'),
    average?: boolean(name='Average'),
    beginType?: string(name='BeginType'),
    botId?: string(name='BotId'),
    caseSensitive?: boolean(name='Case_sensitive'),
    categoryPathCode?: string(name='CategoryPathCode'),
    checkFirstSentence?: boolean(name='CheckFirstSentence'),
    checkType?: int32(name='CheckType'),
    compareOperator?: string(name='CompareOperator'),
    contextChatMatch?: boolean(name='ContextChatMatch'),
    customerParam?: JudgeNodeMetaDesc(name='CustomerParam'),
    delayTime?: int32(name='DelayTime'),
    differentRole?: boolean(name='Different_role'),
    endType?: string(name='EndType'),
    excludes?: [ string ](name='Excludes'),
    from?: int32(name='From'),
    fromEnd?: boolean(name='From_end'),
    hitTime?: int32(name='Hit_time'),
    inSentence?: boolean(name='In_sentence'),
    interval?: int32(name='Interval'),
    intervalEnd?: int32(name='IntervalEnd'),
    keywordExtension?: int32(name='KeywordExtension'),
    keywordMatchSize?: int32(name='KeywordMatchSize'),
    keywords?: [ string ](name='Keywords'),
    knowledgeInfo?: string(name='KnowledgeInfo'),
    knowledgeSentenceNum?: int32(name='KnowledgeSentenceNum'),
    knowledgeTargetId?: string(name='KnowledgeTargetId'),
    knowledgeTargetName?: string(name='KnowledgeTargetName'),
    knowledgeTargetType?: int32(name='KnowledgeTargetType'),
    lgfSentences?: [ string ](name='LgfSentences'),
    maxEmotionChangeValue?: int32(name='MaxEmotionChangeValue'),
    minWordSize?: int32(name='MinWordSize'),
    nearDialogue?: boolean(name='Near_dialogue'),
    notRegex?: string(name='NotRegex'),
    phrase?: string(name='Phrase'),
    pkey?: string(name='Pkey'),
    poutputType?: int32(name='Poutput_type'),
    pvalues?: [ string ](name='Pvalues'),
    questionThreshold?: string(name='QuestionThreshold'),
    references?: [ string ](name='References'),
    regex?: string(name='Regex'),
    roleId?: int32(name='RoleId'),
    score?: int32(name='Score'),
    similarityThreshold?: double(name='Similarity_threshold'),
    similarlySentences?: [ string ](name='SimilarlySentences'),
    synonyms?: map[string][ string ](name='Synonyms'),
    target?: int32(name='Target'),
    targetRole?: string(name='Target_role'),
    threshold?: float(name='Threshold'),
    useEasAlgorithm?: boolean(name='UseEasAlgorithm'),
    velocity?: double(name='Velocity'),
    velocityInMint?: int32(name='VelocityInMint'),
  }(name='Param'),
  qualityCheckType?: int32(name='QualityCheckType'),
  type?: string(name='Type'),
  userGroup?: string(name='UserGroup'),
}

model RuleCountInfo {
  autoReview?: int32(name='AutoReview'),
  businessCategoryBasicInfoList?: [
    BusinessCategoryBasicInfo
  ](name='BusinessCategoryBasicInfoList'),
  businessCategoryNameList?: [ string ](name='BusinessCategoryNameList'),
  businessRange?: [ int32 ](name='BusinessRange'),
  checkNumber?: long(name='CheckNumber'),
  comments?: string(name='Comments'),
  createEmpName?: string(name='CreateEmpName'),
  createEmpid?: string(name='CreateEmpid'),
  createTime?: string(name='CreateTime'),
  deny?: int32(name='Deny'),
  effective?: int32(name='Effective'),
  effectiveEndTime?: string(name='EffectiveEndTime'),
  effectiveStartTime?: string(name='EffectiveStartTime'),
  endTime?: string(name='EndTime'),
  fullCycle?: int32(name='FullCycle'),
  graphFlow?: any(name='GraphFlow'),
  hitNumber?: long(name='HitNumber'),
  hitRate?: float(name='HitRate'),
  hitRealViolationRate?: float(name='HitRealViolationRate'),
  isDelete?: int32(name='IsDelete'),
  isSelect?: boolean(name='IsSelect'),
  jobName?: string(name='JobName'),
  lastUpdateEmpName?: string(name='LastUpdateEmpName'),
  lastUpdateEmpid?: string(name='LastUpdateEmpid'),
  lastUpdateTime?: string(name='LastUpdateTime'),
  name?: string(name='Name'),
  operationMode?: int32(name='OperationMode'),
  preReviewNumber?: long(name='PreReviewNumber'),
  problemNumber?: long(name='ProblemNumber'),
  qualityCheckType?: int32(name='QualityCheckType'),
  realViolationNumber?: int32(name='RealViolationNumber'),
  reviewAccuracyRate?: float(name='ReviewAccuracyRate'),
  reviewNumber?: long(name='ReviewNumber'),
  reviewRate?: float(name='ReviewRate'),
  reviewStatusName?: string(name='ReviewStatusName'),
  rid?: long(name='Rid'),
  ruleScoreSingleType?: int32(name='RuleScoreSingleType'),
  ruleScoreType?: int32(name='RuleScoreType'),
  ruleType?: int32(name='RuleType'),
  scoreSubId?: long(name='ScoreSubId'),
  startTime?: string(name='StartTime'),
  status?: int32(name='Status'),
  targetType?: int32(name='TargetType'),
  type?: int32(name='Type'),
  typeName?: string(name='TypeName'),
  unReviewNumber?: long(name='UnReviewNumber'),
  userGroup?: string(name='UserGroup'),
}

model RuleInfo {
  autoReview?: int32(name='AutoReview'),
  businessCategoryNameList?: [ string ](name='BusinessCategoryNameList'),
  checkType?: long(name='CheckType'),
  comments?: string(name='Comments'),
  configType?: int32(name='ConfigType'),
  createEmpName?: string(name='CreateEmpName'),
  createEmpid?: string(name='CreateEmpid'),
  createTime?: string(name='CreateTime'),
  deny?: int32(name='Deny'),
  dialogues?: [
    RuleTestDialogue
  ](name='Dialogues'),
  effective?: int32(name='Effective'),
  effectiveEndTime?: string(name='EffectiveEndTime'),
  effectiveStartTime?: string(name='EffectiveStartTime'),
  endTime?: string(name='EndTime'),
  externalProperty?: int32(name='ExternalProperty'),
  fullCycle?: int32(name='FullCycle'),
  graphFlow?: any(name='GraphFlow'),
  isDelete?: int32(name='IsDelete'),
  isOnline?: int32(name='IsOnline'),
  lambda?: string(name='Lambda'),
  lastUpdateEmpName?: string(name='LastUpdateEmpName'),
  lastUpdateEmpid?: string(name='LastUpdateEmpid'),
  lastUpdateTime?: string(name='LastUpdateTime'),
  level?: int32(name='Level'),
  meet?: int32(name='Meet'),
  modifyType?: int32(name='ModifyType'),
  name?: string(name='Name'),
  operationMode?: int32(name='OperationMode'),
  qualityCheckType?: int32(name='QualityCheckType'),
  rid?: string(name='Rid'),
  ruleCategoryName?: string(name='RuleCategoryName'),
  ruleScoreType?: int32(name='RuleScoreType'),
  ruleType?: int32(name='RuleType'),
  schemeCheckType?: SchemeCheckType(name='SchemeCheckType'),
  schemeId?: long(name='SchemeId'),
  schemeName?: string(name='SchemeName'),
  schemeRuleMappingId?: long(name='SchemeRuleMappingId'),
  scoreDeleted?: boolean(name='ScoreDeleted'),
  scoreId?: long(name='ScoreId'),
  scoreName?: string(name='ScoreName'),
  scoreNum?: int32(name='ScoreNum'),
  scoreNumType?: int32(name='ScoreNumType'),
  scoreRuleHitType?: int32(name='ScoreRuleHitType'),
  scoreSubId?: long(name='ScoreSubId'),
  scoreSubName?: string(name='ScoreSubName'),
  scoreType?: int32(name='ScoreType'),
  sortIndex?: int32(name='SortIndex'),
  startTime?: string(name='StartTime'),
  status?: int32(name='Status'),
  targetType?: int32(name='TargetType'),
  taskFlowId?: long(name='TaskFlowId'),
  taskFlowType?: int32(name='TaskFlowType'),
  triggers?: [ string ](name='Triggers'),
  type?: int32(name='Type'),
  weight?: string(name='Weight'),
}

model RuleTestDialogue {
  content?: [ 
    {
      begin?: long(name='Begin'),
      beginTime?: long(name='BeginTime'),
      emotionValue?: int32(name='EmotionValue'),
      end?: long(name='End'),
      hourMinSec?: string(name='HourMinSec'),
      identity?: string(name='Identity'),
      role?: string(name='Role'),
      silenceDuration?: long(name='SilenceDuration'),
      speechRate?: long(name='SpeechRate'),
      words?: string(name='Words'),
    }
  ](name='Content'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  userGroup?: string(name='UserGroup'),
}

model RulesInfo {
  conditions?: [
    ConditionBasicInfo
  ](name='Conditions', nullable=true),
  count?: int32(name='Count'),
  dialogues?: [
    RuleTestDialogue
  ](name='Dialogues', nullable=true),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  rules?: [
    RuleInfo
  ](name='Rules'),
}

model SchemeCheckType {
  checkName?: string(name='CheckName'),
  checkType?: long(name='CheckType'),
  enable?: int32(name='Enable'),
  schemeId?: long(name='SchemeId'),
  schemeScoreInfoList?: [ 
    {
      name?: string(name='Name'),
      rid?: long(name='Rid'),
      scoreNum?: int32(name='ScoreNum'),
      scoreNumType?: int32(name='ScoreNumType'),
      scoreRuleHitType?: int32(name='ScoreRuleHitType'),
      scoreType?: int32(name='ScoreType'),
      taskFlowId?: long(name='TaskFlowId'),
      taskFlowName?: string(name='TaskFlowName'),
    }
  ](name='SchemeScoreInfoList'),
  score?: int32(name='Score'),
  sourceScore?: int32(name='SourceScore'),
  taskFlowScoreInfoList?: [ 
    {
      schemeScoreInfoList?: [ 
        {
          name?: string(name='Name'),
          rid?: long(name='Rid'),
          scoreNum?: int32(name='ScoreNum'),
          scoreNumType?: int32(name='ScoreNumType'),
          scoreRuleHitType?: int32(name='ScoreRuleHitType'),
          scoreType?: int32(name='ScoreType'),
          taskFlowId?: long(name='TaskFlowId'),
          taskFlowName?: string(name='TaskFlowName'),
        }
      ](name='SchemeScoreInfoList'),
      taskFlowId?: long(name='TaskFlowId'),
      taskFlowName?: string(name='TaskFlowName'),
      taskFlowType?: int32(name='TaskFlowType'),
    }
  ](name='TaskFlowScoreInfoList'),
}

model TaskGraphFlow {
  flowRuleScoreType?: int32(name='FlowRuleScoreType'),
  id?: long(name='Id'),
  nodes?: [
    GraphFlowNode
  ](name='Nodes'),
  rid?: long(name='Rid'),
  ruleName?: string(name='RuleName'),
  showProperties?: string(name='ShowProperties'),
  skipWhenFirstSessionNodeMiss?: boolean(name='SkipWhenFirstSessionNodeMiss'),
}

model AddBusinessCategoryRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model AddBusinessCategoryResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='348193421'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='76DB5D8C-5BD9-42A7-B527-5AF3A5F83F12'),
  success?: boolean(name='Success', example='true'),
}

model AddBusinessCategoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddBusinessCategoryResponseBody(name='body'),
}

/**
 * @param request AddBusinessCategoryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddBusinessCategoryResponse
 */
async function addBusinessCategoryWithOptions(request: AddBusinessCategoryRequest, runtime: Util.RuntimeOptions): AddBusinessCategoryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddBusinessCategory',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request AddBusinessCategoryRequest
 * @return AddBusinessCategoryResponse
 */
async function addBusinessCategory(request: AddBusinessCategoryRequest): AddBusinessCategoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return addBusinessCategoryWithOptions(request, runtime);
}

model AddRuleCategoryRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model AddRuleCategoryResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    select?: boolean(name='Select'),
    type?: int32(name='Type'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success', example='true'),
}

model AddRuleCategoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddRuleCategoryResponseBody(name='body'),
}

/**
 * @param request AddRuleCategoryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddRuleCategoryResponse
 */
async function addRuleCategoryWithOptions(request: AddRuleCategoryRequest, runtime: Util.RuntimeOptions): AddRuleCategoryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddRuleCategory',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request AddRuleCategoryRequest
 * @return AddRuleCategoryResponse
 */
async function addRuleCategory(request: AddRuleCategoryRequest): AddRuleCategoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return addRuleCategoryWithOptions(request, runtime);
}

model AddRuleV4Request {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  isCopy?: boolean(name='IsCopy', example='false'),
  jsonStrForRule?: string(name='JsonStrForRule', description='This parameter is required.'),
}

model AddRuleV4ResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model AddRuleV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddRuleV4ResponseBody(name='body'),
}

/**
 * @summary V4创建规则
 *
 * @param request AddRuleV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddRuleV4Response
 */
async function addRuleV4WithOptions(request: AddRuleV4Request, runtime: Util.RuntimeOptions): AddRuleV4Response {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.isCopy)) {
    body['IsCopy'] = request.isCopy;
  }
  if (!Util.isUnset(request.jsonStrForRule)) {
    body['JsonStrForRule'] = request.jsonStrForRule;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AddRuleV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary V4创建规则
 *
 * @param request AddRuleV4Request
 * @return AddRuleV4Response
 */
async function addRuleV4(request: AddRuleV4Request): AddRuleV4Response {
  var runtime = new Util.RuntimeOptions{};
  return addRuleV4WithOptions(request, runtime);
}

model ApplyWsTokenRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', example='123456'),
  jsonStr?: string(name='JsonStr', example='{
    "business": "test",
    "callType": 1,
    "callee": "13111111111",
    "caller": "13800000000",
    "skillGroupId": 1,
    "skillGroupName": "test",
    "taskConfigId": 399,
    "tid": "2025012412cb129e-1579-46b5-9326-1b2ececf8f30"
}'),
}

model ApplyWsTokenResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    sessionId?: string(name='SessionId', example='42e59bcd-7206-44c5-ad34-525d364687c4'),
    token?: string(name='Token', example='5607b21d1728700640'),
    wsEndpoint?: string(name='WsEndpoint', example='wss://ws-gateway-real-voice.aliyuncs.com'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  requestId?: string(name='RequestId', description='Id of the request', example='6987D326-83D9-4A42-B9A5-0B27F9B40539'),
}

model ApplyWsTokenResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ApplyWsTokenResponseBody(name='body'),
}

/**
 * @summary 申领实时语音所需token
 *
 * @param request ApplyWsTokenRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ApplyWsTokenResponse
 */
async function applyWsTokenWithOptions(request: ApplyWsTokenRequest, runtime: Util.RuntimeOptions): ApplyWsTokenResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyWsToken',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 申领实时语音所需token
 *
 * @param request ApplyWsTokenRequest
 * @return ApplyWsTokenResponse
 */
async function applyWsToken(request: ApplyWsTokenRequest): ApplyWsTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyWsTokenWithOptions(request, runtime);
}

model AssignReviewerRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"assignmentList":[{"taskId":"1C21CF1E-2917-4236-A046-20E37B293B69","fileId":"7981b466fd6a4c70a7065da159739a5b"},{"taskId":"0111DDBC-5F10-47E0-B7D4-7175F47D626F","fileId":"1814eeae3cff41e989e31ab547f07561"}],"assignments":[{"reviewer":"255746168704895558"},{"reviewer":"268370362815185444"}]}'),
}

model AssignReviewerResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model AssignReviewerResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AssignReviewerResponseBody(name='body'),
}

/**
 * @param request AssignReviewerRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AssignReviewerResponse
 */
async function assignReviewerWithOptions(request: AssignReviewerRequest, runtime: Util.RuntimeOptions): AssignReviewerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AssignReviewer',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request AssignReviewerRequest
 * @return AssignReviewerResponse
 */
async function assignReviewer(request: AssignReviewerRequest): AssignReviewerResponse {
  var runtime = new Util.RuntimeOptions{};
  return assignReviewerWithOptions(request, runtime);
}

model AssignReviewerBySessionGroupRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"sessionGroupParam":{"isSchemeData":1,"callStartTime":"2022-09-17 00:00:00","callEndTime":"2022-09-23 23:59:59","schemeTaskConfigId":24},"assignments":[{"reviewer":63,"count":4}],"isSchemeData":1}'),
}

model AssignReviewerBySessionGroupResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model AssignReviewerBySessionGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AssignReviewerBySessionGroupResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI AssignReviewerBySessionGroup is deprecated
 *
 * @summary 会话组批量分配
 *
 * @param request AssignReviewerBySessionGroupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AssignReviewerBySessionGroupResponse
 */
// Deprecated
async function assignReviewerBySessionGroupWithOptions(request: AssignReviewerBySessionGroupRequest, runtime: Util.RuntimeOptions): AssignReviewerBySessionGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AssignReviewerBySessionGroup',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI AssignReviewerBySessionGroup is deprecated
 *
 * @summary 会话组批量分配
 *
 * @param request AssignReviewerBySessionGroupRequest
 * @return AssignReviewerBySessionGroupResponse
 */
// Deprecated
async function assignReviewerBySessionGroup(request: AssignReviewerBySessionGroupRequest): AssignReviewerBySessionGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return assignReviewerBySessionGroupWithOptions(request, runtime);
}

model BatchSubmitReviewInfoRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"isSchemeData":1,"schemeTaskConfigId":334,"sourceDataType":2,"startTime":"2022-08-25 00:00:00","endTime":"2022-09-23 23:59:59","sessionList":[{"taskId":"20220831-F8D7F4DF-0A16-1A1C-BA63-28F203922692","fileId":"20220831-164343"},{"taskId":"20220831-F2A50A72-82C4-1E3F-A1FD-52A662283D25","fileId":"20220831-164343"}]}'),
}

model BatchSubmitReviewInfoResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model BatchSubmitReviewInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: BatchSubmitReviewInfoResponseBody(name='body'),
}

/**
 * @summary 批量复核
 *
 * @param request BatchSubmitReviewInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return BatchSubmitReviewInfoResponse
 */
async function batchSubmitReviewInfoWithOptions(request: BatchSubmitReviewInfoRequest, runtime: Util.RuntimeOptions): BatchSubmitReviewInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BatchSubmitReviewInfo',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 批量复核
 *
 * @param request BatchSubmitReviewInfoRequest
 * @return BatchSubmitReviewInfoResponse
 */
async function batchSubmitReviewInfo(request: BatchSubmitReviewInfoRequest): BatchSubmitReviewInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchSubmitReviewInfoWithOptions(request, runtime);
}

model CreateAsrVocabRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model CreateAsrVocabResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='71b1795ac8634bd8bdf4d3878480c7c2'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='96138D8D-8D26-4E41-BFF4-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
}

model CreateAsrVocabResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateAsrVocabResponseBody(name='body'),
}

/**
 * @summary 创建热词模型
 *
 * @param request CreateAsrVocabRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateAsrVocabResponse
 */
async function createAsrVocabWithOptions(request: CreateAsrVocabRequest, runtime: Util.RuntimeOptions): CreateAsrVocabResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateAsrVocab',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 创建热词模型
 *
 * @param request CreateAsrVocabRequest
 * @return CreateAsrVocabResponse
 */
async function createAsrVocab(request: CreateAsrVocabRequest): CreateAsrVocabResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAsrVocabWithOptions(request, runtime);
}

model CreateCheckTypeToSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr'),
}

model CreateCheckTypeToSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='5'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model CreateCheckTypeToSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateCheckTypeToSchemeResponseBody(name='body'),
}

/**
 * @summary 创建质检方案中的质检维度
 *
 * @param request CreateCheckTypeToSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateCheckTypeToSchemeResponse
 */
async function createCheckTypeToSchemeWithOptions(request: CreateCheckTypeToSchemeRequest, runtime: Util.RuntimeOptions): CreateCheckTypeToSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCheckTypeToScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 创建质检方案中的质检维度
 *
 * @param request CreateCheckTypeToSchemeRequest
 * @return CreateCheckTypeToSchemeResponse
 */
async function createCheckTypeToScheme(request: CreateCheckTypeToSchemeRequest): CreateCheckTypeToSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCheckTypeToSchemeWithOptions(request, runtime);
}

model CreateQualityCheckSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', description='This parameter is required.'),
}

model CreateQualityCheckSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='12'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='76DB5D8C-5BD9-42A7-B527-5AF3A5F****'),
  success?: boolean(name='Success', example='true'),
}

model CreateQualityCheckSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateQualityCheckSchemeResponseBody(name='body'),
}

/**
 * @summary 新增质检方案
 *
 * @param request CreateQualityCheckSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateQualityCheckSchemeResponse
 */
async function createQualityCheckSchemeWithOptions(request: CreateQualityCheckSchemeRequest, runtime: Util.RuntimeOptions): CreateQualityCheckSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateQualityCheckScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 新增质检方案
 *
 * @param request CreateQualityCheckSchemeRequest
 * @return CreateQualityCheckSchemeResponse
 */
async function createQualityCheckScheme(request: CreateQualityCheckSchemeRequest): CreateQualityCheckSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return createQualityCheckSchemeWithOptions(request, runtime);
}

model CreateSchemeTaskConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr'),
}

model CreateSchemeTaskConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='22'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model CreateSchemeTaskConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateSchemeTaskConfigResponseBody(name='body'),
}

/**
 * @summary 新建质检任务
 *
 * @param request CreateSchemeTaskConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateSchemeTaskConfigResponse
 */
async function createSchemeTaskConfigWithOptions(request: CreateSchemeTaskConfigRequest, runtime: Util.RuntimeOptions): CreateSchemeTaskConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateSchemeTaskConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 新建质检任务
 *
 * @param request CreateSchemeTaskConfigRequest
 * @return CreateSchemeTaskConfigResponse
 */
async function createSchemeTaskConfig(request: CreateSchemeTaskConfigRequest): CreateSchemeTaskConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSchemeTaskConfigWithOptions(request, runtime);
}

model CreateSkillGroupConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"skillGroupFrom":0,"qualityCheckType":0,"modelId":746,"name":"test","rid":"2493","vocabId":"267","skillGroupList":[{"skillGroupId":"0903","skillGroupName":"0903"}]}'),
}

model CreateSkillGroupConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='223'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model CreateSkillGroupConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateSkillGroupConfigResponseBody(name='body'),
}

/**
 * @param request CreateSkillGroupConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateSkillGroupConfigResponse
 */
async function createSkillGroupConfigWithOptions(request: CreateSkillGroupConfigRequest, runtime: Util.RuntimeOptions): CreateSkillGroupConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateSkillGroupConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateSkillGroupConfigRequest
 * @return CreateSkillGroupConfigResponse
 */
async function createSkillGroupConfig(request: CreateSkillGroupConfigRequest): CreateSkillGroupConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSkillGroupConfigWithOptions(request, runtime);
}

model CreateTaskAssignRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model CreateTaskAssignRuleResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='54'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model CreateTaskAssignRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateTaskAssignRuleResponseBody(name='body'),
}

/**
 * @param request CreateTaskAssignRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateTaskAssignRuleResponse
 */
async function createTaskAssignRuleWithOptions(request: CreateTaskAssignRuleRequest, runtime: Util.RuntimeOptions): CreateTaskAssignRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateTaskAssignRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateTaskAssignRuleRequest
 * @return CreateTaskAssignRuleResponse
 */
async function createTaskAssignRule(request: CreateTaskAssignRuleRequest): CreateTaskAssignRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTaskAssignRuleWithOptions(request, runtime);
}

model CreateWarningConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model CreateWarningConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='30'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model CreateWarningConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateWarningConfigResponseBody(name='body'),
}

/**
 * @param request CreateWarningConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateWarningConfigResponse
 */
async function createWarningConfigWithOptions(request: CreateWarningConfigRequest, runtime: Util.RuntimeOptions): CreateWarningConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateWarningConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateWarningConfigRequest
 * @return CreateWarningConfigResponse
 */
async function createWarningConfig(request: CreateWarningConfigRequest): CreateWarningConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWarningConfigWithOptions(request, runtime);
}

model CreateWarningStrategyConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model CreateWarningStrategyConfigResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateWarningStrategyConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateWarningStrategyConfigResponseBody(name='body'),
}

/**
 * @summary  预警策略-新增
 *
 * @param request CreateWarningStrategyConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateWarningStrategyConfigResponse
 */
async function createWarningStrategyConfigWithOptions(request: CreateWarningStrategyConfigRequest, runtime: Util.RuntimeOptions): CreateWarningStrategyConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateWarningStrategyConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary  预警策略-新增
 *
 * @param request CreateWarningStrategyConfigRequest
 * @return CreateWarningStrategyConfigResponse
 */
async function createWarningStrategyConfig(request: CreateWarningStrategyConfigRequest): CreateWarningStrategyConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWarningStrategyConfigWithOptions(request, runtime);
}

model DelRuleCategoryRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model DelRuleCategoryResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    select?: boolean(name='Select', example='false'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='xxx'),
  success?: boolean(name='Success', example='true'),
}

model DelRuleCategoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DelRuleCategoryResponseBody(name='body'),
}

/**
 * @param request DelRuleCategoryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DelRuleCategoryResponse
 */
async function delRuleCategoryWithOptions(request: DelRuleCategoryRequest, runtime: Util.RuntimeOptions): DelRuleCategoryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DelRuleCategory',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DelRuleCategoryRequest
 * @return DelRuleCategoryResponse
 */
async function delRuleCategory(request: DelRuleCategoryRequest): DelRuleCategoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return delRuleCategoryWithOptions(request, runtime);
}

model DeleteAsrVocabRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model DeleteAsrVocabResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='71b1795ac8634bd8bdf4d3878480c7c2'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model DeleteAsrVocabResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAsrVocabResponseBody(name='body'),
}

/**
 * @param request DeleteAsrVocabRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteAsrVocabResponse
 */
async function deleteAsrVocabWithOptions(request: DeleteAsrVocabRequest, runtime: Util.RuntimeOptions): DeleteAsrVocabResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAsrVocab',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteAsrVocabRequest
 * @return DeleteAsrVocabResponse
 */
async function deleteAsrVocab(request: DeleteAsrVocabRequest): DeleteAsrVocabResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAsrVocabWithOptions(request, runtime);
}

model DeleteBusinessCategoryRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model DeleteBusinessCategoryResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model DeleteBusinessCategoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteBusinessCategoryResponseBody(name='body'),
}

/**
 * @param request DeleteBusinessCategoryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteBusinessCategoryResponse
 */
async function deleteBusinessCategoryWithOptions(request: DeleteBusinessCategoryRequest, runtime: Util.RuntimeOptions): DeleteBusinessCategoryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteBusinessCategory',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteBusinessCategoryRequest
 * @return DeleteBusinessCategoryResponse
 */
async function deleteBusinessCategory(request: DeleteBusinessCategoryRequest): DeleteBusinessCategoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBusinessCategoryWithOptions(request, runtime);
}

model DeleteCheckTypeToSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', example='123456'),
  jsonStr?: string(name='JsonStr', example='{"schemeId":"1376","checkType":"4"}'),
}

model DeleteCheckTypeToSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='48864'),
  message?: string(name='Message', example='successful'),
  messages?: [ string ](name='Messages'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model DeleteCheckTypeToSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteCheckTypeToSchemeResponseBody(name='body'),
}

/**
 * @summary 删除质检唯独
 *
 * @param request DeleteCheckTypeToSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteCheckTypeToSchemeResponse
 */
async function deleteCheckTypeToSchemeWithOptions(request: DeleteCheckTypeToSchemeRequest, runtime: Util.RuntimeOptions): DeleteCheckTypeToSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteCheckTypeToScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 删除质检唯独
 *
 * @param request DeleteCheckTypeToSchemeRequest
 * @return DeleteCheckTypeToSchemeResponse
 */
async function deleteCheckTypeToScheme(request: DeleteCheckTypeToSchemeRequest): DeleteCheckTypeToSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCheckTypeToSchemeWithOptions(request, runtime);
}

model DeleteCustomizationConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"modelId":"2412"}'),
}

model DeleteCustomizationConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='252'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model DeleteCustomizationConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteCustomizationConfigResponseBody(name='body'),
}

/**
 * @param request DeleteCustomizationConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteCustomizationConfigResponse
 */
async function deleteCustomizationConfigWithOptions(request: DeleteCustomizationConfigRequest, runtime: Util.RuntimeOptions): DeleteCustomizationConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteCustomizationConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteCustomizationConfigRequest
 * @return DeleteCustomizationConfigResponse
 */
async function deleteCustomizationConfig(request: DeleteCustomizationConfigRequest): DeleteCustomizationConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCustomizationConfigWithOptions(request, runtime);
}

model DeleteDataSetRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"setId":"234"}'),
}

model DeleteDataSetResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model DeleteDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteDataSetResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI DeleteDataSet is deprecated
 *
 * @param request DeleteDataSetRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteDataSetResponse
 */
// Deprecated
async function deleteDataSetWithOptions(request: DeleteDataSetRequest, runtime: Util.RuntimeOptions): DeleteDataSetResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteDataSet',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI DeleteDataSet is deprecated
 *
 * @param request DeleteDataSetRequest
 * @return DeleteDataSetResponse
 */
// Deprecated
async function deleteDataSet(request: DeleteDataSetRequest): DeleteDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteDataSetWithOptions(request, runtime);
}

model DeletePrecisionTaskRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='"{"taskId": "7C1DEF5F-2C18-4D36-99C6*******"}"'),
}

model DeletePrecisionTaskResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model DeletePrecisionTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeletePrecisionTaskResponseBody(name='body'),
}

/**
 * @param request DeletePrecisionTaskRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeletePrecisionTaskResponse
 */
async function deletePrecisionTaskWithOptions(request: DeletePrecisionTaskRequest, runtime: Util.RuntimeOptions): DeletePrecisionTaskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeletePrecisionTask',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeletePrecisionTaskRequest
 * @return DeletePrecisionTaskResponse
 */
async function deletePrecisionTask(request: DeletePrecisionTaskRequest): DeletePrecisionTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return deletePrecisionTaskWithOptions(request, runtime);
}

model DeleteQualityCheckSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"schemeId":191}'),
}

model DeleteQualityCheckSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model DeleteQualityCheckSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteQualityCheckSchemeResponseBody(name='body'),
}

/**
 * @summary 删除质检方案
 *
 * @param request DeleteQualityCheckSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteQualityCheckSchemeResponse
 */
async function deleteQualityCheckSchemeWithOptions(request: DeleteQualityCheckSchemeRequest, runtime: Util.RuntimeOptions): DeleteQualityCheckSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteQualityCheckScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 删除质检方案
 *
 * @param request DeleteQualityCheckSchemeRequest
 * @return DeleteQualityCheckSchemeResponse
 */
async function deleteQualityCheckScheme(request: DeleteQualityCheckSchemeRequest): DeleteQualityCheckSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteQualityCheckSchemeWithOptions(request, runtime);
}

model DeleteRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  forceDelete?: boolean(name='ForceDelete', example='true'),
  isSchemeData?: int32(name='IsSchemeData', example='1'),
  ruleId?: long(name='RuleId', description='This parameter is required.', example='1'),
}

model DeleteRuleResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model DeleteRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteRuleResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI DeleteRule is deprecated, please use Qualitycheck::2019-01-15::DeleteRuleV4 instead.
 *
 * @summary 删除规则
 *
 * @param request DeleteRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteRuleResponse
 */
// Deprecated
async function deleteRuleWithOptions(request: DeleteRuleRequest, runtime: Util.RuntimeOptions): DeleteRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.forceDelete)) {
    body['ForceDelete'] = request.forceDelete;
  }
  if (!Util.isUnset(request.isSchemeData)) {
    body['IsSchemeData'] = request.isSchemeData;
  }
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI DeleteRule is deprecated, please use Qualitycheck::2019-01-15::DeleteRuleV4 instead.
 *
 * @summary 删除规则
 *
 * @param request DeleteRuleRequest
 * @return DeleteRuleResponse
 */
// Deprecated
async function deleteRule(request: DeleteRuleRequest): DeleteRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteRuleWithOptions(request, runtime);
}

model DeleteRuleV4Request {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  forceDelete?: boolean(name='ForceDelete', example='false'),
  ruleId?: long(name='RuleId', description='This parameter is required.', example='1'),
}

model DeleteRuleV4ResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model DeleteRuleV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteRuleV4ResponseBody(name='body'),
}

/**
 * @summary V4删除规则
 *
 * @param request DeleteRuleV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteRuleV4Response
 */
async function deleteRuleV4WithOptions(request: DeleteRuleV4Request, runtime: Util.RuntimeOptions): DeleteRuleV4Response {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.forceDelete)) {
    body['ForceDelete'] = request.forceDelete;
  }
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteRuleV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary V4删除规则
 *
 * @param request DeleteRuleV4Request
 * @return DeleteRuleV4Response
 */
async function deleteRuleV4(request: DeleteRuleV4Request): DeleteRuleV4Response {
  var runtime = new Util.RuntimeOptions{};
  return deleteRuleV4WithOptions(request, runtime);
}

model DeleteSchemeTaskConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"schemeId":"329"}'),
}

model DeleteSchemeTaskConfigResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model DeleteSchemeTaskConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteSchemeTaskConfigResponseBody(name='body'),
}

/**
 * @summary 删除质检任务
 *
 * @param request DeleteSchemeTaskConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteSchemeTaskConfigResponse
 */
async function deleteSchemeTaskConfigWithOptions(request: DeleteSchemeTaskConfigRequest, runtime: Util.RuntimeOptions): DeleteSchemeTaskConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteSchemeTaskConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 删除质检任务
 *
 * @param request DeleteSchemeTaskConfigRequest
 * @return DeleteSchemeTaskConfigResponse
 */
async function deleteSchemeTaskConfig(request: DeleteSchemeTaskConfigRequest): DeleteSchemeTaskConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSchemeTaskConfigWithOptions(request, runtime);
}

model DeleteSkillGroupConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"id":552}'),
}

model DeleteSkillGroupConfigResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model DeleteSkillGroupConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteSkillGroupConfigResponseBody(name='body'),
}

/**
 * @param request DeleteSkillGroupConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteSkillGroupConfigResponse
 */
async function deleteSkillGroupConfigWithOptions(request: DeleteSkillGroupConfigRequest, runtime: Util.RuntimeOptions): DeleteSkillGroupConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteSkillGroupConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteSkillGroupConfigRequest
 * @return DeleteSkillGroupConfigResponse
 */
async function deleteSkillGroupConfig(request: DeleteSkillGroupConfigRequest): DeleteSkillGroupConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSkillGroupConfigWithOptions(request, runtime);
}

model DeleteTaskAssignRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"ruleId": 24}'),
}

model DeleteTaskAssignRuleResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model DeleteTaskAssignRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteTaskAssignRuleResponseBody(name='body'),
}

/**
 * @param request DeleteTaskAssignRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteTaskAssignRuleResponse
 */
async function deleteTaskAssignRuleWithOptions(request: DeleteTaskAssignRuleRequest, runtime: Util.RuntimeOptions): DeleteTaskAssignRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteTaskAssignRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteTaskAssignRuleRequest
 * @return DeleteTaskAssignRuleResponse
 */
async function deleteTaskAssignRule(request: DeleteTaskAssignRuleRequest): DeleteTaskAssignRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteTaskAssignRuleWithOptions(request, runtime);
}

model DeleteWarningConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"configId": "31"}'),
}

model DeleteWarningConfigResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model DeleteWarningConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteWarningConfigResponseBody(name='body'),
}

/**
 * @param request DeleteWarningConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteWarningConfigResponse
 */
async function deleteWarningConfigWithOptions(request: DeleteWarningConfigRequest, runtime: Util.RuntimeOptions): DeleteWarningConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteWarningConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteWarningConfigRequest
 * @return DeleteWarningConfigResponse
 */
async function deleteWarningConfig(request: DeleteWarningConfigRequest): DeleteWarningConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteWarningConfigWithOptions(request, runtime);
}

model DeleteWarningStrategyConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model DeleteWarningStrategyConfigResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteWarningStrategyConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteWarningStrategyConfigResponseBody(name='body'),
}

/**
 * @summary  预警策略-删除
 *
 * @param request DeleteWarningStrategyConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteWarningStrategyConfigResponse
 */
async function deleteWarningStrategyConfigWithOptions(request: DeleteWarningStrategyConfigRequest, runtime: Util.RuntimeOptions): DeleteWarningStrategyConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteWarningStrategyConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary  预警策略-删除
 *
 * @param request DeleteWarningStrategyConfigRequest
 * @return DeleteWarningStrategyConfigResponse
 */
async function deleteWarningStrategyConfig(request: DeleteWarningStrategyConfigRequest): DeleteWarningStrategyConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteWarningStrategyConfigWithOptions(request, runtime);
}

model GetAsrVocabRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr'),
}

model GetAsrVocabResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    asrVersion?: int32(name='AsrVersion'),
    modelCustomizationId?: string(name='ModelCustomizationId'),
    name?: string(name='Name', example='test'),
    words?: {
      word?: [ 
      {
        weight?: int32(name='Weight', example='0'),
        word?: string(name='Word'),
      }
    ](name='Word')
    }(name='Words'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model GetAsrVocabResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAsrVocabResponseBody(name='body'),
}

/**
 * @param request GetAsrVocabRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetAsrVocabResponse
 */
async function getAsrVocabWithOptions(request: GetAsrVocabRequest, runtime: Util.RuntimeOptions): GetAsrVocabResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAsrVocab',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetAsrVocabRequest
 * @return GetAsrVocabResponse
 */
async function getAsrVocab(request: GetAsrVocabRequest): GetAsrVocabResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAsrVocabWithOptions(request, runtime);
}

model GetBusinessCategoryListRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='""'),
}

model GetBusinessCategoryListResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    businessCategoryBasicInfo?: [ 
    {
      bid?: int32(name='Bid', example='0'),
      businessName?: string(name='BusinessName'),
      serviceType?: int32(name='ServiceType', example='0'),
    }
  ](name='BusinessCategoryBasicInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='A186A419-FDBE-464C-AED4-7121CAC73BF1'),
  success?: boolean(name='Success', example='false'),
}

model GetBusinessCategoryListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessCategoryListResponseBody(name='body'),
}

/**
 * @param request GetBusinessCategoryListRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetBusinessCategoryListResponse
 */
async function getBusinessCategoryListWithOptions(request: GetBusinessCategoryListRequest, runtime: Util.RuntimeOptions): GetBusinessCategoryListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessCategoryList',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetBusinessCategoryListRequest
 * @return GetBusinessCategoryListResponse
 */
async function getBusinessCategoryList(request: GetBusinessCategoryListRequest): GetBusinessCategoryListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessCategoryListWithOptions(request, runtime);
}

model GetCustomizationConfigListRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='""'),
}

model GetCustomizationConfigListResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    modelCustomizationDataSetPo?: [ 
    {
      asrVersion?: int32(name='AsrVersion'),
      createTime?: string(name='CreateTime', example='2019-01-08'),
      modeCustomizationId?: string(name='ModeCustomizationId', example='cdae396590bb479a9ec40f3476e274fc'),
      modelId?: long(name='ModelId', example='1'),
      modelName?: string(name='ModelName'),
      modelStatus?: int32(name='ModelStatus', example='5'),
      taskType?: int32(name='TaskType', example='1'),
    }
  ](name='ModelCustomizationDataSetPo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model GetCustomizationConfigListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCustomizationConfigListResponseBody(name='body'),
}

/**
 * @summary 获取语音模型列表
 *
 * @param request GetCustomizationConfigListRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetCustomizationConfigListResponse
 */
async function getCustomizationConfigListWithOptions(request: GetCustomizationConfigListRequest, runtime: Util.RuntimeOptions): GetCustomizationConfigListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCustomizationConfigList',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 获取语音模型列表
 *
 * @param request GetCustomizationConfigListRequest
 * @return GetCustomizationConfigListResponse
 */
async function getCustomizationConfigList(request: GetCustomizationConfigListRequest): GetCustomizationConfigListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCustomizationConfigListWithOptions(request, runtime);
}

model GetNextResultToVerifyRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='"{"pageNumber":1,"pageSize":1,"taskId":"593A04C0-E6E9-4CDC-8C9*****","original":1}"'),
}

model GetNextResultToVerifyResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    audioScheme?: string(name='AudioScheme', example='http'),
    audioURL?: string(name='AudioURL', example='sca-bucket.oss-cn-hangzhou.aliyuncs.com/upload_1173636551461420/dateset_1584674455133_SzC/%E4%BA%BA%E5%B7%A5%E6%A0%A1%E9%AA%8C%E6%B5%8B%E8%AF%95-%E6%9F%A5%E5%8C%97%E4%BA%AC%E5%A4%A9%E6%B0%94.wav?Expires=1584847372&amp;OSSAccessKeyId=*****&amp;Signature=HccAKnLOJwoYvzE*********'),
    dialogues?: {
      dialogue?: [ 
      {
        begin?: long(name='Begin', example='980'),
        beginTime?: string(name='BeginTime', example='XXX'),
        deltas?: {
          delta?: [ 
          {
            source?: {
              line?: {
                line?: [ string ](name='Line')
              }(name='Line'),
              position?: int32(name='Position', example='5'),
            }(name='Source'),
            target?: {
              line?: {
                line?: [ string ](name='Line')
              }(name='Line'),
              position?: int32(name='Position', example='5'),
            }(name='Target'),
            type?: string(name='Type', example='CHANGE'),
          }
        ](name='Delta')
        }(name='Deltas'),
        emotionValue?: int32(name='EmotionValue', example='6'),
        end?: long(name='End', example='3422'),
        hourMinSec?: string(name='HourMinSec', example='00:00:07'),
        identity?: string(name='Identity'),
        incorrectWords?: int32(name='IncorrectWords', example='2'),
        role?: string(name='Role'),
        silenceDuration?: int32(name='SilenceDuration', example='1'),
        sourceRole?: string(name='SourceRole'),
        sourceWords?: string(name='SourceWords'),
        speechRate?: int32(name='SpeechRate', example='332'),
        words?: string(name='Words'),
      }
    ](name='Dialogue')
    }(name='Dialogues'),
    duration?: int32(name='Duration', example='23421'),
    fileId?: string(name='FileId', example='e790e6c919d84b82b64ee*****'),
    fileName?: string(name='FileName', example='xxx.wav'),
    incorrectWords?: int32(name='IncorrectWords', example='23'),
    index?: int32(name='Index', example='2'),
    precision?: float(name='Precision', example='0.97079998'),
    status?: int32(name='Status', example='3'),
    totalCount?: int32(name='TotalCount', example='3'),
    updateTime?: string(name='UpdateTime', example='2020-03-20T11:26Z'),
    verified?: boolean(name='Verified', example='true'),
    verifiedCount?: int32(name='VerifiedCount', example='2'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model GetNextResultToVerifyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetNextResultToVerifyResponseBody(name='body'),
}

/**
 * @param request GetNextResultToVerifyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetNextResultToVerifyResponse
 */
async function getNextResultToVerifyWithOptions(request: GetNextResultToVerifyRequest, runtime: Util.RuntimeOptions): GetNextResultToVerifyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetNextResultToVerify',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetNextResultToVerifyRequest
 * @return GetNextResultToVerifyResponse
 */
async function getNextResultToVerify(request: GetNextResultToVerifyRequest): GetNextResultToVerifyResponse {
  var runtime = new Util.RuntimeOptions{};
  return getNextResultToVerifyWithOptions(request, runtime);
}

model GetPrecisionTaskRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='"{"taskId":"593A04C0-E6E9-4CDC-8C9****"}"'),
}

model GetPrecisionTaskResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    dataSetId?: long(name='DataSetId', example='1212'),
    dataSetName?: string(name='DataSetName'),
    duration?: int32(name='Duration', example='3423'),
    incorrectWords?: int32(name='IncorrectWords', example='23'),
    name?: string(name='Name'),
    precisions?: {
      precision?: [ 
      {
        modelId?: long(name='ModelId', example='2311'),
        modelName?: string(name='ModelName'),
        precision?: float(name='Precision', example='0.98'),
        status?: int32(name='Status', example='1'),
        taskId?: string(name='TaskId', example='593A04C0-E6E9-4CDC-8C99-B120C******'),
      }
    ](name='Precision')
    }(name='Precisions'),
    source?: int32(name='Source', example='3'),
    status?: int32(name='Status', example='1'),
    taskId?: string(name='TaskId', example='7C1DEF5F-2C18-4D36-99C6-8C27*****'),
    totalCount?: int32(name='TotalCount', example='3'),
    updateTime?: string(name='UpdateTime', example='2020-03-10 20:26:29'),
    verifiedCount?: int32(name='VerifiedCount', example='2'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model GetPrecisionTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPrecisionTaskResponseBody(name='body'),
}

/**
 * @param request GetPrecisionTaskRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetPrecisionTaskResponse
 */
async function getPrecisionTaskWithOptions(request: GetPrecisionTaskRequest, runtime: Util.RuntimeOptions): GetPrecisionTaskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPrecisionTask',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetPrecisionTaskRequest
 * @return GetPrecisionTaskResponse
 */
async function getPrecisionTask(request: GetPrecisionTaskRequest): GetPrecisionTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPrecisionTaskWithOptions(request, runtime);
}

model GetQualityCheckSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"schemeId":"187","ruleRequireInfos":["BusinessNameInfo","RuleCategory"]}'),
}

model GetQualityCheckSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    createTime?: string(name='CreateTime', example='1616113198000'),
    createUserName?: string(name='CreateUserName', example='xxx'),
    dataType?: int32(name='DataType', example='1'),
    description?: string(name='Description'),
    initScore?: string(name='InitScore'),
    name?: string(name='Name', example='xxx'),
    ruleIds?: [ string ](name='RuleIds'),
    ruleList?: [
      RulesInfo
    ](name='RuleList'),
    schemeCheckTypeList?: [ 
      {
        checkName?: string(name='CheckName'),
        checkType?: long(name='CheckType', example='0'),
        enable?: int32(name='Enable', example='1'),
        schemeId?: long(name='SchemeId', example='32'),
        score?: int32(name='Score', example='20'),
        sourceScore?: int32(name='SourceScore', example='10'),
      }
    ](name='SchemeCheckTypeList'),
    schemeId?: long(name='SchemeId', example='112**'),
    schemeTemplateId?: long(name='SchemeTemplateId', example='1'),
    status?: int32(name='Status', example='1'),
    templateType?: int32(name='TemplateType', example='1'),
    type?: int32(name='Type', example='1'),
    updateTime?: string(name='UpdateTime', example='1616113198000'),
    updateUserName?: string(name='UpdateUserName', example='xxx'),
    version?: long(name='Version', example='1616113198000'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: [ string ](name='Messages'),
  requestId?: string(name='RequestId', example='96138D8D-8D26-4E41-BFF4-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
}

model GetQualityCheckSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetQualityCheckSchemeResponseBody(name='body'),
}

/**
 * @summary 获取质检方案
 *
 * @param request GetQualityCheckSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetQualityCheckSchemeResponse
 */
async function getQualityCheckSchemeWithOptions(request: GetQualityCheckSchemeRequest, runtime: Util.RuntimeOptions): GetQualityCheckSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetQualityCheckScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 获取质检方案
 *
 * @param request GetQualityCheckSchemeRequest
 * @return GetQualityCheckSchemeResponse
 */
async function getQualityCheckScheme(request: GetQualityCheckSchemeRequest): GetQualityCheckSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQualityCheckSchemeWithOptions(request, runtime);
}

model GetResultRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10,"excludeFields":"hitResult.hits, recording.url","requiredFields":"agent,status,errorMessage,reviewStatus,reviewResult,score,taskId,reviewer,resolver,recording.name,recording.duration,hitResult,business","dataType":1,"sourceType":0,"startTime":"2020-06-25 00:00:00","endTime":"2020-07-01 23:59:59"}'),
}

model GetResultResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='1'),
  data?: {
    resultInfo?: [ 
    {
      agent?: {
        id?: string(name='Id', example='28240****15643'),
        name?: string(name='Name'),
        skillGroup?: string(name='SkillGroup'),
      }(name='Agent'),
      asrResult?: {
        asrResult?: [ 
        {
          begin?: long(name='Begin', example='10000'),
          emotionValue?: int32(name='EmotionValue', example='1'),
          end?: long(name='End', example='0'),
          identity?: string(name='Identity'),
          role?: string(name='Role'),
          speechRate?: int32(name='SpeechRate', example='50'),
          words?: string(name='Words', example='xx'),
        }
      ](name='AsrResult')
      }(name='AsrResult'),
      assignmentTime?: string(name='AssignmentTime', example='2021-03-02T14:37Z'),
      comments?: string(name='Comments', example='xx'),
      createTime?: string(name='CreateTime', example='2019-07-24T19:31Z'),
      createTimeLong?: string(name='CreateTimeLong', example='1602743090'),
      errorMessage?: string(name='ErrorMessage', example='xxx'),
      hitResult?: {
        hitResult?: [ 
        {
          conditions?: {
            conditions?: [ 
            {
              checkRange?: {
                absolute?: boolean(name='Absolute', description='false: 相对位置; 会结合anchor以及角色来决定句子位置'),
                allSentencesSatisfy?: boolean(name='AllSentencesSatisfy', description='true: 每句话都必须满足条件；'),
                anchor?: {
                  cid?: string(name='Cid', description='条件ID'),
                  hitTime?: int32(name='Hit_time', description='命中次数'),
                  location?: string(name='Location', description='位置'),
                }(name='Anchor', description='前置后置条件'),
                range?: {
                  from?: int32(name='From', description='对话开始索引'),
                  to?: int32(name='To', description='对话结束索引'),
                }(name='Range', description='相对范围'),
                role?: string(name='Role', description='对应 RoleType.type'),
                roleId?: int32(name='RoleId', description='对应 RoleType.id'),
                timeRange?: {
                  from?: long(name='From'),
                  to?: long(name='To'),
                }(name='TimeRange'),
              }(name='Check_range', description='检测范围'),
              cid?: string(name='Cid', description='条件id，可能是db中的主键，也可能是转换成的a, b, c'),
              exclusion?: int32(name='Exclusion', description='排除'),
              id?: long(name='Id', description='在db中的主键'),
              lambda?: string(name='Lambda', description='Lambda表达式：例如:a&&b'),
              operators?: {
                operator?: [ 
                {
                  id?: long(name='Id', description='主键id'),
                  name?: string(name='Name', description='算子名'),
                  oid?: string(name='Oid', description='可能是主键id，也可能是前端生成的id'),
                  param?: {
                    average?: boolean(name='Average', description='语速检测，是否计算整个对话平均语速，默认false'),
                    beginType?: string(name='BeginType', description='时长算子，时长计算开始类型，录音开始，还是某句对话开始'),
                    caseSensitive?: boolean(name='Case_sensitive', description='区分大小写'),
                    checkFirstSentence?: boolean(name='CheckFirstSentence', description='静音检测：要不要检测第一句话'),
                    checkType?: int32(name='CheckType', description='检测方式，1 相邻句能量波动 2 最大能量跨度 默认1'),
                    compareOperator?: string(name='CompareOperator', description='大于，还是小于，gt/lt'),
                    contextChatMatch?: boolean(name='ContextChatMatch', description='是否单句话匹配；'),
                    delayTime?: int32(name='DelayTime', description='抢话算子 延时时长'),
                    endType?: string(name='EndType', description='时长算子，时长计算结束类型，录音结束，还是某句对话结束'),
                    excludes?: {
                      exclude?: [ string ](name='Exclude')
                    }(name='Excludes', description='上下文重复算子：排除掉某些对话'),
                    flowNodePrerequisiteParam?: {
                      nodeId?: long(name='NodeId', description='节点id'),
                      nodeMatchStatus?: int32(name='NodeMatchStatus', description='节点匹配状态。'),
                      nodeName?: string(name='NodeName', description='冗余的节点名称'),
                    }(name='FlowNodePrerequisiteParam', description='流程节点前置条件参数'),
                    from?: int32(name='From', description='上下文重复算子：检测当前句的前from句是否有重复；0表示前面的所有句'),
                    fromEnd?: boolean(name='From_end', description='from_end'),
                    hitTime?: int32(name='Hit_time', description='上下文重复算子：重复几次'),
                    inSentence?: boolean(name='In_sentence', description='生效句子， true单个句子，false多个句子'),
                    intentModelCheckParm?: {
                      intents?: {
                        intent?: [ 
                        {
                          id?: long(name='Id', description='意图模型ID'),
                          name?: string(name='Name', description='意图模型名称'),
                        }
                      ](name='Intent')
                      }(name='Intents', description='引用的意图模型'),
                      modelScene?: string(name='ModelScene', description='模型应用的场景 AGENT:客户场景、CUSTOMER:客服场景 (CUSTOMER: 客户场景, AGENT: 坐席场景)'),
                    }(name='IntentModelCheckParm', description='意图模型检查参数'),
                    interval?: int32(name='Interval', description='interval代表区间范围开始'),
                    intervalEnd?: int32(name='IntervalEnd', description='intervalEnd 代表区间范围结束'),
                    keywordExtension?: int32(name='KeywordExtension', description='关键字扩展'),
                    keywordMatchSize?: int32(name='KeywordMatchSize', description='匹配到的关键字数量'),
                    keywords?: {
                      keyword?: [ string ](name='Keyword')
                    }(name='Keywords', description='关键词'),
                    maxEmotionChangeValue?: int32(name='MaxEmotionChangeValue', description='能量值变化，默认3, 1~9'),
                    minWordSize?: int32(name='MinWordSize', description='句子中最少字数，小于此字数的句子不检查'),
                    nearDialogue?: boolean(name='Near_dialogue', description='true表示取不同角色相邻的两句话，false表示取不同角色的第一句话比较响应时间（默认）'),
                    notRegex?: string(name='NotRegex', description='排除的正则表达式'),
                    phrase?: string(name='Phrase', description='语句'),
                    regex?: string(name='Regex', description='正则表达式'),
                    target?: int32(name='Target', description='target'),
                    threshold?: float(name='Threshold', description='阈值'),
                  }(name='Param', description='算子参数'),
                  type?: string(name='Type', description='算子类别'),
                }
              ](name='Operator')
              }(name='Operators', description='算子列表'),
              rid?: string(name='Rid', description='条件所属的规则id'),
            }
          ](name='Conditions')
          }(name='Conditions'),
          hits?: {
            hit?: [ 
            {
              cid?: {
                cid?: [ string ](name='Cid')
              }(name='Cid'),
              keyWords?: {
                keyWord?: [ 
                {
                  cid?: string(name='Cid', example='xxxx'),
                  from?: int32(name='From', example='1'),
                  to?: int32(name='To', example='2'),
                  val?: string(name='Val', example='test'),
                }
              ](name='KeyWord')
              }(name='KeyWords'),
              phrase?: {
                begin?: long(name='Begin', example='300'),
                emotionValue?: int32(name='EmotionValue', example='0'),
                end?: int32(name='End', example='300'),
                role?: string(name='Role'),
                words?: string(name='Words', example='xxx'),
              }(name='Phrase'),
            }
          ](name='Hit')
          }(name='Hits'),
          name?: string(name='Name'),
          reviewResult?: int32(name='ReviewResult', example='0'),
          rid?: string(name='Rid', example='1276'),
          schemeId?: long(name='SchemeId', example='123xx'),
          schemeVersion?: long(name='SchemeVersion', example='11xx'),
          score?: int32(name='Score'),
          type?: string(name='Type'),
        }
      ](name='HitResult')
      }(name='HitResult'),
      hitScore?: {
        hitScore?: [ 
        {
          ruleId?: string(name='RuleId', example='123'),
          scoreId?: string(name='ScoreId', example='123456'),
          scoreName?: string(name='ScoreName'),
          scoreNumber?: string(name='ScoreNumber', example='-20'),
        }
      ](name='HitScore')
      }(name='HitScore'),
      lastDataId?: string(name='LastDataId', example='4498420@a_z@93EAADF1-01D3-44BD-8AC9-F57F447EFCE8_1614*****'),
      recording?: {
        business?: string(name='Business'),
        callId?: string(name='CallId', example='XXXX'),
        callTime?: string(name='CallTime', example='1563967699000'),
        callType?: int32(name='CallType', example='1'),
        callee?: string(name='Callee', example='1888888****'),
        caller?: string(name='Caller', example='0108888****'),
        customerName?: string(name='CustomerName'),
        dataSetName?: string(name='DataSetName', example='XXXX'),
        dialogueSize?: int32(name='DialogueSize', example='32'),
        duration?: long(name='Duration', example='60'),
        id?: string(name='Id', example='XXXXX'),
        name?: string(name='Name', example='123456.mkv'),
        primaryId?: string(name='PrimaryId', example='3437500'),
        remark1?: string(name='Remark1', example='XXX'),
        remark10?: string(name='Remark10', example='XXX'),
        remark11?: string(name='Remark11', example='XXX'),
        remark12?: string(name='Remark12', example='XXX'),
        remark13?: string(name='Remark13', example='XXX'),
        remark2?: string(name='Remark2', example='XXX'),
        remark3?: string(name='Remark3', example='XXX'),
        remark4?: string(name='Remark4', example='XXX'),
        remark5?: long(name='Remark5', example='1232'),
        remark6?: string(name='Remark6', example='XXX'),
        remark7?: string(name='Remark7', example='XXX'),
        remark8?: string(name='Remark8', example='XXX'),
        remark9?: string(name='Remark9', example='XXX'),
        taskConfigId?: long(name='TaskConfigId'),
        taskConfigName?: string(name='TaskConfigName'),
        url?: string(name='Url', example='http://aliyun.com/audio.wav'),
      }(name='Recording'),
      resolver?: string(name='Resolver', example='XXX'),
      reviewHistoryList?: {
        reviewHistory?: [ 
        {
          comments?: string(name='Comments'),
          complainResult?: int32(name='ComplainResult'),
          oldScore?: int32(name='OldScore'),
          operator?: long(name='Operator'),
          operatorName?: string(name='OperatorName'),
          reviewManagerType?: string(name='ReviewManagerType'),
          reviewResult?: int32(name='ReviewResult'),
          reviewRightRule?: {
            reviewRightRule?: [ 
            {
              rid?: long(name='rid'),
              ruleName?: string(name='ruleName'),
            }
          ](name='ReviewRightRule')
          }(name='ReviewRightRule'),
          score?: int32(name='Score'),
          time?: long(name='Time'),
          timeStr?: string(name='TimeStr'),
          type?: int32(name='Type'),
        }
      ](name='ReviewHistory')
      }(name='ReviewHistoryList'),
      reviewResult?: int32(name='ReviewResult', example='0'),
      reviewStatus?: int32(name='ReviewStatus', example='1'),
      reviewTime?: string(name='ReviewTime', example='2019-07-24T19:31Z'),
      reviewTimeLong?: string(name='ReviewTimeLong', example='1602743090'),
      reviewType?: int32(name='ReviewType', example='1'),
      reviewTypeIdList?: {
        reviewTypeIdList?: [ 
        {
          reviewKeyIdList?: {
            reviewKeyIdList?: [ long ](name='ReviewKeyIdList')
          }(name='ReviewKeyIdList'),
          reviewTypeId?: long(name='ReviewTypeId'),
        }
      ](name='ReviewTypeIdList')
      }(name='ReviewTypeIdList'),
      reviewer?: string(name='Reviewer', example='xxx'),
      schemeIdList?: {
        schemeIdList?: [ long ](name='SchemeIdList')
      }(name='SchemeIdList'),
      schemeNameList?: {
        schemeNameList?: [ string ](name='SchemeNameList')
      }(name='SchemeNameList'),
      score?: int32(name='Score', example='100'),
      status?: int32(name='Status', example='0'),
      taskId?: string(name='TaskId', example='A6BEC8D-9A5B-4BE5-8432-4F635E***'),
      taskName?: string(name='TaskName', example='test'),
      vid?: string(name='Vid'),
    }
  ](name='ResultInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  resultCountId?: string(name='ResultCountId', example='XXX'),
  success?: boolean(name='Success', example='true'),
}

model GetResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetResultResponseBody(name='body'),
}

/**
 * @param request GetResultRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetResultResponse
 */
async function getResultWithOptions(request: GetResultRequest, runtime: Util.RuntimeOptions): GetResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetResult',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetResultRequest
 * @return GetResultResponse
 */
async function getResult(request: GetResultRequest): GetResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return getResultWithOptions(request, runtime);
}

model GetResultToReviewRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model GetResultToReviewResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    audioScheme?: string(name='AudioScheme', example='https'),
    audioURL?: string(name='AudioURL', example='sca-ccc-test.oss-cn-beijing.aliyuncs.com/xxxxx'),
    comments?: string(name='Comments', example='xxx'),
    dialogues?: {
      dialogue?: [ 
      {
        begin?: long(name='Begin', example='72000'),
        beginTime?: string(name='BeginTime', example='2019-10-01 11:12:01'),
        beginTimeMs?: long(name='BeginTimeMs'),
        emotionValue?: int32(name='EmotionValue', example='7'),
        end?: long(name='End', example='80000'),
        hourMinSec?: string(name='HourMinSec', example='00:08'),
        identity?: string(name='Identity'),
        role?: string(name='Role'),
        silenceDuration?: int32(name='SilenceDuration', example='1'),
        speechRate?: int32(name='SpeechRate', example='200'),
        words?: string(name='Words'),
      }
    ](name='Dialogue')
    }(name='Dialogues'),
    fileId?: string(name='FileId', example='e790e6c919d84b82b64ee*****'),
    fileMergeName?: string(name='FileMergeName', example='xxx.wav'),
    hitRuleReviewInfoList?: {
      hitRuleReviewInfo?: [ 
      {
        autoReview?: int32(name='AutoReview', example='1'),
        complainHistories?: {
          complainHistories?: [ 
          {
            comments?: string(name='Comments'),
            operationTime?: string(name='OperationTime', example='2020-10-16T11:13Z'),
            operationType?: int32(name='OperationType', example='5'),
            operator?: long(name='Operator', example='123456'),
            operatorName?: string(name='OperatorName'),
          }
        ](name='ComplainHistories')
        }(name='ComplainHistories'),
        complainable?: boolean(name='Complainable', example='true'),
        conditionHitInfoList?: {
          conditionHitInfo?: [ 
          {
            cid?: {
              cid?: [ string ](name='Cid')
            }(name='Cid'),
            keyWords?: {
              keyWord?: [ 
              {
                cid?: string(name='Cid', example='2000'),
                customizeCode?: string(name='CustomizeCode', example='xxx'),
                from?: int32(name='From', example='1'),
                pid?: int32(name='Pid', example='2'),
                tid?: string(name='Tid', example='6fa76916-3ce6-45d8-ac64-01b7f31c7295'),
                to?: int32(name='To', example='3'),
                val?: string(name='Val'),
              }
            ](name='KeyWord')
            }(name='KeyWords'),
            phrase?: {
              begin?: long(name='Begin', example='72000'),
              emotionValue?: int32(name='EmotionValue', example='7'),
              end?: long(name='End', example='80000'),
              identity?: string(name='Identity'),
              pid?: int32(name='Pid', example='3'),
              role?: string(name='Role'),
              words?: string(name='Words'),
            }(name='Phrase'),
          }
        ](name='ConditionHitInfo')
        }(name='ConditionHitInfoList'),
        reviewInfo?: {
          hitId?: string(name='HitId', example='013c68142fec4f0899fa6ee0exxx'),
          reviewResult?: int32(name='ReviewResult', example='1'),
          reviewTime?: string(name='ReviewTime', example='2019-10-12 17:06:00'),
          reviewer?: string(name='Reviewer', example='123'),
          rid?: long(name='Rid', example='451'),
        }(name='ReviewInfo'),
        rid?: long(name='Rid', example='451'),
        ruleName?: string(name='RuleName'),
        scoreId?: long(name='ScoreId', example='xxx'),
        scoreNum?: int32(name='ScoreNum', example='-10'),
        scoreSubId?: long(name='ScoreSubId', example='xxx'),
        scoreSubName?: string(name='ScoreSubName', example='xxx'),
      }
    ](name='HitRuleReviewInfo')
    }(name='HitRuleReviewInfoList'),
    manualScoreInfoList?: {
      manualScoreInfo?: [ 
      {
        complainHistories?: {
          complainHistories?: [ 
          {
            comments?: string(name='Comments'),
            operationTime?: string(name='OperationTime', example='2020-10-16T11:13Z'),
            operationType?: int32(name='OperationType', example='5'),
            operator?: long(name='Operator', example='123456'),
            operatorName?: string(name='OperatorName'),
          }
        ](name='ComplainHistories')
        }(name='ComplainHistories'),
        complainable?: boolean(name='Complainable', example='true'),
        scoreId?: long(name='ScoreId', example='xxx'),
        scoreNum?: int32(name='ScoreNum', example='-10'),
        scoreSubId?: long(name='ScoreSubId', example='xxx'),
        scoreSubName?: string(name='ScoreSubName'),
      }
    ](name='ManualScoreInfo')
    }(name='ManualScoreInfoList'),
    reviewHistoryList?: {
      reviewHistory?: [ 
      {
        comments?: string(name='Comments'),
        complainResult?: int32(name='ComplainResult', example='1'),
        oldScore?: int32(name='OldScore', example='90'),
        operator?: long(name='Operator'),
        operatorName?: string(name='OperatorName'),
        reviewManagerType?: string(name='ReviewManagerType'),
        reviewResult?: int32(name='ReviewResult', example='1'),
        reviewRightRule?: {
          reviewRightRule?: [ 
          {
            rid?: long(name='rid'),
            ruleName?: string(name='ruleName'),
          }
        ](name='ReviewRightRule')
        }(name='ReviewRightRule'),
        score?: int32(name='Score', example='95'),
        time?: long(name='Time'),
        timeStr?: string(name='TimeStr', example='2019-10-28 15:21:00'),
        type?: int32(name='Type', example='1'),
      }
    ](name='ReviewHistory')
    }(name='ReviewHistoryList'),
    reviewTypeIdList?: {
      reviewTypeIdList?: [ 
      {
        reviewKeyIdList?: {
          reviewKeyIdList?: [ long ](name='ReviewKeyIdList')
        }(name='ReviewKeyIdList'),
        reviewTypeId?: long(name='ReviewTypeId'),
      }
    ](name='ReviewTypeIdList')
    }(name='ReviewTypeIdList'),
    status?: int32(name='Status', example='1'),
    totalScore?: int32(name='TotalScore', example='99'),
    vid?: string(name='Vid', example='6fa76916-3ce6-45d8-ac64-01b7f31***'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4***'),
  success?: boolean(name='Success', example='true'),
}

model GetResultToReviewResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetResultToReviewResponseBody(name='body'),
}

/**
 * @param request GetResultToReviewRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetResultToReviewResponse
 */
async function getResultToReviewWithOptions(request: GetResultToReviewRequest, runtime: Util.RuntimeOptions): GetResultToReviewResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetResultToReview',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetResultToReviewRequest
 * @return GetResultToReviewResponse
 */
async function getResultToReview(request: GetResultToReviewRequest): GetResultToReviewResponse {
  var runtime = new Util.RuntimeOptions{};
  return getResultToReviewWithOptions(request, runtime);
}

model GetRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"ruleIds":"123"}'),
}

model GetRuleResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    rules?: {
      ruleInfo?: [ 
      {
        autoReview?: int32(name='AutoReview', example='1'),
        businessCategoryNameList?: {
          businessCategoryNameList?: [ string ](name='BusinessCategoryNameList')
        }(name='BusinessCategoryNameList'),
        comments?: string(name='Comments'),
        createEmpid?: string(name='CreateEmpid', example='123'),
        createTime?: string(name='CreateTime', example='2016-08-05 10:37:10'),
        endTime?: string(name='EndTime', example='2016-08-05 10:37:10'),
        isDelete?: int32(name='IsDelete', example='0'),
        isOnline?: int32(name='IsOnline', example='1'),
        lastUpdateEmpid?: string(name='LastUpdateEmpid', example='123'),
        lastUpdateTime?: string(name='LastUpdateTime', example='2019-10-28 14:23:28'),
        name?: string(name='Name', example='demo'),
        rid?: string(name='Rid', example='4'),
        ruleLambda?: string(name='RuleLambda', example='a && b'),
        ruleScoreType?: int32(name='RuleScoreType', example='1'),
        scoreId?: int32(name='ScoreId', example='123'),
        scoreName?: string(name='ScoreName'),
        scoreSubId?: int32(name='ScoreSubId', example='22'),
        scoreSubName?: string(name='ScoreSubName'),
        startTime?: string(name='StartTime', example='2016-08-05 10:37:10'),
        status?: int32(name='Status', example='1'),
        type?: int32(name='Type', example='1'),
        weight?: string(name='Weight', example='1'),
      }
    ](name='RuleInfo')
    }(name='Rules'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model GetRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRuleResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI GetRule is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @param request GetRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRuleResponse
 */
// Deprecated
async function getRuleWithOptions(request: GetRuleRequest, runtime: Util.RuntimeOptions): GetRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI GetRule is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @param request GetRuleRequest
 * @return GetRuleResponse
 */
// Deprecated
async function getRule(request: GetRuleRequest): GetRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRuleWithOptions(request, runtime);
}

model GetRuleByIdRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  ruleId?: long(name='RuleId', description='This parameter is required.', example='53'),
}

model GetRuleByIdResponseBody = {
  code?: string(name='Code', example='200'),
  data?: RulesInfo(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: [ string ](name='Messages'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model GetRuleByIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRuleByIdResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI GetRuleById is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @summary 获取规则
 *
 * @param request GetRuleByIdRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRuleByIdResponse
 */
// Deprecated
async function getRuleByIdWithOptions(request: GetRuleByIdRequest, runtime: Util.RuntimeOptions): GetRuleByIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetRuleById',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI GetRuleById is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @summary 获取规则
 *
 * @param request GetRuleByIdRequest
 * @return GetRuleByIdResponse
 */
// Deprecated
async function getRuleById(request: GetRuleByIdRequest): GetRuleByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRuleByIdWithOptions(request, runtime);
}

model GetRuleCategoryRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='""'),
}

model GetRuleCategoryResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    ruleCountInfo?: [ 
    {
      select?: boolean(name='Select', example='false'),
      type?: int32(name='Type', example='22'),
      typeName?: string(name='TypeName'),
    }
  ](name='RuleCountInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model GetRuleCategoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRuleCategoryResponseBody(name='body'),
}

/**
 * @param request GetRuleCategoryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRuleCategoryResponse
 */
async function getRuleCategoryWithOptions(request: GetRuleCategoryRequest, runtime: Util.RuntimeOptions): GetRuleCategoryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRuleCategory',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetRuleCategoryRequest
 * @return GetRuleCategoryResponse
 */
async function getRuleCategory(request: GetRuleCategoryRequest): GetRuleCategoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRuleCategoryWithOptions(request, runtime);
}

model GetRuleDetailRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"ruleIds":"123"}'),
}

model GetRuleDetailResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    conditions?: {
      conditionBasicInfo?: [ 
      {
        checkRange?: {
          absolute?: boolean(name='Absolute', example='true'),
          anchor?: {
            anchorCid?: string(name='AnchorCid', example='7'),
            hitTime?: int32(name='HitTime', example='1'),
            location?: string(name='Location', example='AFTER'),
          }(name='Anchor'),
          range?: {
            from?: int32(name='From', example='1'),
            to?: int32(name='To', example='10'),
          }(name='Range'),
          role?: string(name='Role'),
        }(name='CheckRange'),
        conditionInfoCid?: string(name='ConditionInfoCid', example='7'),
        operLambda?: string(name='OperLambda', example='7'),
        operators?: {
          operatorBasicInfo?: [ 
          {
            oid?: string(name='Oid', example='8'),
            operName?: string(name='OperName', example='operator demo'),
            param?: {
              antModelInfo?: {
                antModelInfo?: [ string ](name='AntModelInfo')
              }(name='AntModelInfo'),
              average?: boolean(name='Average', example='true'),
              beginType?: string(name='BeginType', example='DIALOGUE'),
              checkType?: int32(name='CheckType', example='1'),
              compareOperator?: string(name='CompareOperator', example='gt'),
              contextChatMatch?: boolean(name='ContextChatMatch', example='true'),
              delayTime?: int32(name='DelayTime', example='1000'),
              differentRole?: boolean(name='DifferentRole', example='true'),
              excludes?: {
                excludes?: [ string ](name='Excludes')
              }(name='Excludes'),
              from?: int32(name='From', example='3'),
              fromEnd?: boolean(name='FromEnd', example='true'),
              hitTime?: int32(name='HitTime', example='1'),
              inSentence?: boolean(name='InSentence', example='true'),
              interval?: int32(name='Interval', example='5000'),
              keywordExtension?: boolean(name='KeywordExtension', example='true'),
              keywordMatchSize?: int32(name='KeywordMatchSize', example='3'),
              maxEmotionChangeValue?: int32(name='MaxEmotionChangeValue', example='8'),
              minWordSize?: int32(name='MinWordSize', example='4'),
              notRegex?: string(name='NotRegex'),
              operKeyWords?: {
                operKeyWord?: [ string ](name='OperKeyWord')
              }(name='OperKeyWords'),
              phrase?: string(name='Phrase', example='xxx'),
              pvalues?: {
                pvalues?: [ string ](name='Pvalues')
              }(name='Pvalues'),
              references?: {
                reference?: [ string ](name='Reference')
              }(name='References'),
              regex?: string(name='Regex'),
              score?: int32(name='Score', example='80'),
              similarityThreshold?: float(name='Similarity_threshold', example='90'),
              similarlySentences?: {
                similarlySentence?: [ string ](name='SimilarlySentence')
              }(name='SimilarlySentences'),
              target?: int32(name='Target', example='1'),
              targetRole?: string(name='TargetRole'),
              threshold?: float(name='Threshold', example='4'),
              velocityInMint?: int32(name='VelocityInMint', example='280'),
            }(name='Param'),
            type?: string(name='Type', example='REGULAR_EXPRESSION'),
          }
        ](name='OperatorBasicInfo')
        }(name='Operators'),
      }
    ](name='ConditionBasicInfo')
    }(name='Conditions'),
    count?: int32(name='Count', example='10'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    rules?: {
      ruleBasicInfo?: [ 
      {
        businessCategories?: {
          businessCategoryBasicInfo?: [ 
          {
            bid?: int32(name='Bid', example='264971810'),
            businessName?: string(name='BusinessName'),
            serviceType?: int32(name='ServiceType', example='1'),
          }
        ](name='BusinessCategoryBasicInfo')
        }(name='BusinessCategories'),
        rid?: string(name='Rid', example='4'),
        ruleLambda?: string(name='RuleLambda', example='7&&!8'),
        triggers?: {
          trigger?: [ string ](name='Trigger')
        }(name='Triggers'),
      }
    ](name='RuleBasicInfo')
    }(name='Rules'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model GetRuleDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRuleDetailResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI GetRuleDetail is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @param request GetRuleDetailRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRuleDetailResponse
 */
// Deprecated
async function getRuleDetailWithOptions(request: GetRuleDetailRequest, runtime: Util.RuntimeOptions): GetRuleDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRuleDetail',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI GetRuleDetail is deprecated, please use Qualitycheck::2019-01-15::GetRuleV4 instead.
 *
 * @param request GetRuleDetailRequest
 * @return GetRuleDetailResponse
 */
// Deprecated
async function getRuleDetail(request: GetRuleDetailRequest): GetRuleDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRuleDetailWithOptions(request, runtime);
}

model GetRuleV4Request {
  ruleId?: long(name='RuleId', description='This parameter is required.'),
}

model GetRuleV4ResponseBody = {
  code?: string(name='Code', example='200'),
  data?: RulesInfo(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: [ string ](name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model GetRuleV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRuleV4ResponseBody(name='body'),
}

/**
 * @summary V4获取规则
 *
 * @param request GetRuleV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRuleV4Response
 */
async function getRuleV4WithOptions(request: GetRuleV4Request, runtime: Util.RuntimeOptions): GetRuleV4Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetRuleV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary V4获取规则
 *
 * @param request GetRuleV4Request
 * @return GetRuleV4Response
 */
async function getRuleV4(request: GetRuleV4Request): GetRuleV4Response {
  var runtime = new Util.RuntimeOptions{};
  return getRuleV4WithOptions(request, runtime);
}

model GetRulesCountListRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  businessName?: string(name='BusinessName'),
  businessRange?: int32(name='BusinessRange', example='1'),
  categoryName?: string(name='CategoryName'),
  countTotal?: boolean(name='CountTotal', example='true'),
  createEmpid?: string(name='CreateEmpid', example='63'),
  createUserId?: long(name='CreateUserId', example='63'),
  currentPage?: int32(name='CurrentPage', example='1'),
  endTime?: string(name='EndTime', example='2022-10-08 23:59:59'),
  lastUpdateEmpid?: string(name='LastUpdateEmpid', example='63'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requireInfos?: [ string ](name='RequireInfos'),
  rid?: long(name='Rid', example='123'),
  ruleIdOrRuleName?: string(name='RuleIdOrRuleName', example='123'),
  ruleScoreSingleType?: int32(name='RuleScoreSingleType', example='1'),
  ruleType?: int32(name='RuleType', example='1'),
  schemeId?: long(name='SchemeId', example='123'),
  sourceType?: int32(name='SourceType', example='0'),
  startTime?: string(name='StartTime', example='2022-10-07 00:00:00'),
  status?: int32(name='Status', example='1'),
  type?: int32(name='Type', example='1'),
  typeName?: string(name='TypeName'),
  updateEndTime?: string(name='UpdateEndTime', example='2022-10-08 23:59:59'),
  updateStartTime?: string(name='UpdateStartTime', example='2022-10-07 00:00:00'),
  updateUserId?: long(name='UpdateUserId', example='63'),
}

model GetRulesCountListResponseBody = {
  businessType?: int32(name='BusinessType'),
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='20'),
  currentPage?: int32(name='CurrentPage', example='1'),
  data?: {
    data?: [ string ](name='Data')
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
  totalCount?: int32(name='TotalCount', example='7'),
}

model GetRulesCountListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRulesCountListResponseBody(name='body'),
}

/**
 * @summary 获得规则列表
 *
 * @param request GetRulesCountListRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetRulesCountListResponse
 */
async function getRulesCountListWithOptions(request: GetRulesCountListRequest, runtime: Util.RuntimeOptions): GetRulesCountListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.businessName)) {
    body['BusinessName'] = request.businessName;
  }
  if (!Util.isUnset(request.businessRange)) {
    body['BusinessRange'] = request.businessRange;
  }
  if (!Util.isUnset(request.categoryName)) {
    body['CategoryName'] = request.categoryName;
  }
  if (!Util.isUnset(request.countTotal)) {
    body['CountTotal'] = request.countTotal;
  }
  if (!Util.isUnset(request.createEmpid)) {
    body['CreateEmpid'] = request.createEmpid;
  }
  if (!Util.isUnset(request.createUserId)) {
    body['CreateUserId'] = request.createUserId;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endTime)) {
    body['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.lastUpdateEmpid)) {
    body['LastUpdateEmpid'] = request.lastUpdateEmpid;
  }
  if (!Util.isUnset(request.pageNumber)) {
    body['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requireInfos)) {
    body['RequireInfos'] = request.requireInfos;
  }
  if (!Util.isUnset(request.rid)) {
    body['Rid'] = request.rid;
  }
  if (!Util.isUnset(request.ruleIdOrRuleName)) {
    body['RuleIdOrRuleName'] = request.ruleIdOrRuleName;
  }
  if (!Util.isUnset(request.ruleScoreSingleType)) {
    body['RuleScoreSingleType'] = request.ruleScoreSingleType;
  }
  if (!Util.isUnset(request.ruleType)) {
    body['RuleType'] = request.ruleType;
  }
  if (!Util.isUnset(request.schemeId)) {
    body['SchemeId'] = request.schemeId;
  }
  if (!Util.isUnset(request.sourceType)) {
    body['SourceType'] = request.sourceType;
  }
  if (!Util.isUnset(request.startTime)) {
    body['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.status)) {
    body['Status'] = request.status;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.typeName)) {
    body['TypeName'] = request.typeName;
  }
  if (!Util.isUnset(request.updateEndTime)) {
    body['UpdateEndTime'] = request.updateEndTime;
  }
  if (!Util.isUnset(request.updateStartTime)) {
    body['UpdateStartTime'] = request.updateStartTime;
  }
  if (!Util.isUnset(request.updateUserId)) {
    body['UpdateUserId'] = request.updateUserId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetRulesCountList',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 获得规则列表
 *
 * @param request GetRulesCountListRequest
 * @return GetRulesCountListResponse
 */
async function getRulesCountList(request: GetRulesCountListRequest): GetRulesCountListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRulesCountListWithOptions(request, runtime);
}

model GetScoreInfoRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='""'),
}

model GetScoreInfoResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    scorePo?: [ 
    {
      scoreId?: int32(name='ScoreId', example='34'),
      scoreInfos?: {
        scoreParam?: [ 
        {
          scoreNum?: int32(name='ScoreNum', example='32'),
          scoreSubId?: int32(name='ScoreSubId', example='3422'),
          scoreSubName?: string(name='ScoreSubName'),
          scoreType?: int32(name='ScoreType', example='1'),
        }
      ](name='ScoreParam')
      }(name='ScoreInfos'),
      scoreName?: string(name='ScoreName'),
    }
  ](name='ScorePo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model GetScoreInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScoreInfoResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI GetScoreInfo is deprecated
 *
 * @param request GetScoreInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetScoreInfoResponse
 */
// Deprecated
async function getScoreInfoWithOptions(request: GetScoreInfoRequest, runtime: Util.RuntimeOptions): GetScoreInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScoreInfo',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI GetScoreInfo is deprecated
 *
 * @param request GetScoreInfoRequest
 * @return GetScoreInfoResponse
 */
// Deprecated
async function getScoreInfo(request: GetScoreInfoRequest): GetScoreInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScoreInfoWithOptions(request, runtime);
}

model GetSkillGroupConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model GetSkillGroupConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    allContentQualityCheck?: int32(name='AllContentQualityCheck', example='1'),
    allRids?: string(name='AllRids', example='223'),
    allRuleList?: {
      ruleNameInfo?: [ 
      {
        rid?: long(name='Rid', example='12'),
        ruleName?: string(name='RuleName', example='test'),
      }
    ](name='RuleNameInfo')
    }(name='AllRuleList'),
    createTime?: string(name='CreateTime', example='2020-12-01T15:12Z'),
    id?: long(name='Id', example='1212'),
    instanceId?: string(name='InstanceId', example='xxx'),
    modelId?: long(name='ModelId', example='1321'),
    modelName?: string(name='ModelName', example='xxx'),
    name?: string(name='Name', example='xxx'),
    qualityCheckType?: int32(name='QualityCheckType', example='0'),
    rid?: string(name='Rid', example='2332'),
    ruleList?: {
      ruleNameInfo?: [ 
      {
        rid?: long(name='Rid', example='222'),
        ruleName?: string(name='RuleName', example='test'),
      }
    ](name='RuleNameInfo')
    }(name='RuleList'),
    skillGroupFrom?: int32(name='SkillGroupFrom', example='0'),
    skillGroupId?: string(name='SkillGroupId', example='111'),
    skillGroupName?: string(name='SkillGroupName', example='xxx'),
    status?: int32(name='Status', example='0'),
    type?: int32(name='Type', example='1'),
    updateTime?: string(name='UpdateTime', example='2020-12-01T19:28Z'),
    vocabId?: long(name='VocabId', example='123'),
    vocabName?: string(name='VocabName', example='test'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model GetSkillGroupConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSkillGroupConfigResponseBody(name='body'),
}

/**
 * @param request GetSkillGroupConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSkillGroupConfigResponse
 */
async function getSkillGroupConfigWithOptions(request: GetSkillGroupConfigRequest, runtime: Util.RuntimeOptions): GetSkillGroupConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetSkillGroupConfigRequest
 * @return GetSkillGroupConfigResponse
 */
async function getSkillGroupConfig(request: GetSkillGroupConfigRequest): GetSkillGroupConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupConfigWithOptions(request, runtime);
}

model GetSyncResultRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10,"requiredFields":"asrResult,agent,status,errorMessage,reviewStatus,reviewResult,score,taskId,reviewer,resolver,recording.name,recording.duration,recording.url,hitResult,business","startTime":"2020-12-25 00:00:00","endTime":"2020-12-31 23:59:59"}'),
}

model GetSyncResultResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='1'),
  data?: [ 
    {
      agent?: {
        id?: string(name='Id', example='12221'),
        name?: string(name='Name'),
        skillGroup?: string(name='SkillGroup'),
      }(name='Agent'),
      asrResult?: [ 
        {
          begin?: long(name='Begin', example='340'),
          emotionValue?: int32(name='EmotionValue', example='6'),
          end?: long(name='End', example='3000'),
          role?: string(name='Role'),
          silenceDuration?: int32(name='SilenceDuration', example='11'),
          speechRate?: int32(name='SpeechRate', example='221'),
          words?: string(name='Words'),
        }
      ](name='AsrResult'),
      comments?: string(name='Comments', example='xxx'),
      createTime?: string(name='CreateTime', example='2019-07-24T19:31Z'),
      errorMessage?: string(name='ErrorMessage', example='xxxx'),
      hitResult?: [ 
        {
          hits?: [ 
            {
              cid?: [ string ](name='Cid'),
              keyWords?: [ 
                {
                  cid?: string(name='Cid', example='66666'),
                  from?: int32(name='From', example='2'),
                  to?: int32(name='To', example='5'),
                  val?: string(name='Val'),
                }
              ](name='KeyWords'),
              phrase?: {
                begin?: long(name='Begin', example='440'),
                emotionValue?: int32(name='EmotionValue', example='6'),
                end?: int32(name='End', example='4000'),
                role?: string(name='Role'),
                silenceDuration?: int32(name='SilenceDuration', example='1'),
                speechRate?: int32(name='SpeechRate', example='234'),
                words?: string(name='Words'),
              }(name='Phrase'),
            }
          ](name='Hits'),
          name?: string(name='Name'),
          reviewResult?: int32(name='ReviewResult', example='1'),
          rid?: string(name='Rid', example='1211'),
          type?: string(name='Type', example='2'),
        }
      ](name='HitResult'),
      recording?: {
        business?: string(name='Business'),
        callId?: string(name='CallId', example='xxx'),
        callTime?: string(name='CallTime', example='1563967699000'),
        callType?: int32(name='CallType', example='1'),
        callee?: string(name='Callee', example='1888888***'),
        caller?: string(name='Caller', example='0108888****'),
        dataSetName?: string(name='DataSetName', example='xxx'),
        duration?: long(name='Duration', example='232'),
        durationAudio?: long(name='DurationAudio', example='120'),
        id?: string(name='Id', example='xxxx'),
        name?: string(name='Name', example='123123.wav'),
        primaryId?: string(name='PrimaryId', example='xxxx'),
        remark1?: string(name='Remark1', example='xxx'),
        remark2?: string(name='Remark2', example='xxx'),
        remark3?: string(name='Remark3', example='xxx'),
        url?: string(name='Url', example='http://aliyun.com/xxx.wav'),
      }(name='Recording'),
      resolver?: string(name='Resolver'),
      reviewResult?: int32(name='ReviewResult', example='3'),
      reviewStatus?: int32(name='ReviewStatus', example='1'),
      reviewer?: string(name='Reviewer'),
      score?: int32(name='Score', example='100'),
      status?: int32(name='Status', example='1'),
      taskId?: string(name='TaskId', example='20201231de3d34ec-40fa-4a55-8d27-76ea*****'),
      taskName?: string(name='TaskName', example='xxx'),
    }
  ](name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='76DB5D8C-5BD9-42A7-B527-5AF3A5F****'),
  resultCountId?: string(name='ResultCountId', example='xxx'),
  success?: boolean(name='Success', example='true'),
}

model GetSyncResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSyncResultResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI GetSyncResult is deprecated, please use Qualitycheck::2019-01-15::GetResult instead.
 *
 * @param request GetSyncResultRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetSyncResultResponse
 */
// Deprecated
async function getSyncResultWithOptions(request: GetSyncResultRequest, runtime: Util.RuntimeOptions): GetSyncResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSyncResult',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI GetSyncResult is deprecated, please use Qualitycheck::2019-01-15::GetResult instead.
 *
 * @param request GetSyncResultRequest
 * @return GetSyncResultResponse
 */
// Deprecated
async function getSyncResult(request: GetSyncResultRequest): GetSyncResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSyncResultWithOptions(request, runtime);
}

model GetWarningStrategyConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model GetWarningStrategyConfigResponseBody = {
  code?: string(name='Code'),
  data?: {
    id?: long(name='Id'),
    intervalTime?: long(name='IntervalTime'),
    lambda?: string(name='Lambda'),
    level?: long(name='Level'),
    maxNumber?: long(name='MaxNumber'),
    name?: string(name='Name'),
    warningStrategyList?: {
      warningStrategyList?: [ 
      {
        code?: string(name='Code'),
        duration?: long(name='Duration'),
        durationExpression?: long(name='DurationExpression'),
        hitNumber?: long(name='HitNumber'),
        hitNumberExpression?: long(name='HitNumberExpression'),
        hitRuleList?: string(name='HitRuleList'),
        hitType?: long(name='HitType'),
        id?: long(name='Id'),
        range?: {
          rangeNum?: long(name='RangeNum'),
          type?: long(name='Type'),
        }(name='Range'),
        status?: long(name='Status'),
      }
    ](name='warningStrategyList')
    }(name='WarningStrategyList'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetWarningStrategyConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetWarningStrategyConfigResponseBody(name='body'),
}

/**
 * @summary 预警策略-详情
 *
 * @param request GetWarningStrategyConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetWarningStrategyConfigResponse
 */
async function getWarningStrategyConfigWithOptions(request: GetWarningStrategyConfigRequest, runtime: Util.RuntimeOptions): GetWarningStrategyConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetWarningStrategyConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 预警策略-详情
 *
 * @param request GetWarningStrategyConfigRequest
 * @return GetWarningStrategyConfigResponse
 */
async function getWarningStrategyConfig(request: GetWarningStrategyConfigRequest): GetWarningStrategyConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getWarningStrategyConfigWithOptions(request, runtime);
}

model HandleComplaintRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model HandleComplaintResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model HandleComplaintResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: HandleComplaintResponseBody(name='body'),
}

/**
 * @param request HandleComplaintRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return HandleComplaintResponse
 */
async function handleComplaintWithOptions(request: HandleComplaintRequest, runtime: Util.RuntimeOptions): HandleComplaintResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'HandleComplaint',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request HandleComplaintRequest
 * @return HandleComplaintResponse
 */
async function handleComplaint(request: HandleComplaintRequest): HandleComplaintResponse {
  var runtime = new Util.RuntimeOptions{};
  return handleComplaintWithOptions(request, runtime);
}

model InvalidRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"ruleIds":[3,4]}'),
}

model InvalidRuleResponseBody = {
  code?: string(name='Code', example='200'),
  data?: boolean(name='Data', example='true'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model InvalidRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: InvalidRuleResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI InvalidRule is deprecated, please use Qualitycheck::2019-01-15::DeleteRuleV4 instead.
 *
 * @param request InvalidRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return InvalidRuleResponse
 */
// Deprecated
async function invalidRuleWithOptions(request: InvalidRuleRequest, runtime: Util.RuntimeOptions): InvalidRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'InvalidRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI InvalidRule is deprecated, please use Qualitycheck::2019-01-15::DeleteRuleV4 instead.
 *
 * @param request InvalidRuleRequest
 * @return InvalidRuleResponse
 */
// Deprecated
async function invalidRule(request: InvalidRuleRequest): InvalidRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return invalidRuleWithOptions(request, runtime);
}

model ListAsrVocabRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageSize":1}'),
}

model ListAsrVocabResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    asrVocab?: [ 
    {
      asrVersion?: int32(name='AsrVersion'),
      createTime?: string(name='CreateTime', example='2019-04-15T14:57Z'),
      id?: string(name='Id', example='18'),
      modelCustomizationId?: string(name='ModelCustomizationId'),
      name?: string(name='Name'),
      updateTime?: string(name='UpdateTime', example='2019-04-15T14:57Z'),
      vocabularyId?: string(name='VocabularyId', example='a01daaaxxxxxxxxx'),
    }
  ](name='AsrVocab')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='66E1ACB8-17B2-4BE8-8581-954A8EE1324B'),
  success?: boolean(name='Success', example='true'),
}

model ListAsrVocabResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListAsrVocabResponseBody(name='body'),
}

/**
 * @summary 获取热词模型列表
 *
 * @param request ListAsrVocabRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListAsrVocabResponse
 */
async function listAsrVocabWithOptions(request: ListAsrVocabRequest, runtime: Util.RuntimeOptions): ListAsrVocabResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListAsrVocab',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 获取热词模型列表
 *
 * @param request ListAsrVocabRequest
 * @return ListAsrVocabResponse
 */
async function listAsrVocab(request: ListAsrVocabRequest): ListAsrVocabResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAsrVocabWithOptions(request, runtime);
}

model ListDataSetRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', example='{"pageNumber":1,"pageSize":10}'),
}

model ListDataSetResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='23'),
  currentPage?: int32(name='CurrentPage', example='10'),
  data?: {
    data?: [ 
    {
      autoTranscoding?: int32(name='AutoTranscoding', example='1'),
      channelId0?: int32(name='ChannelId0', example='0'),
      channelId1?: int32(name='ChannelId1', example='1'),
      channelType?: int32(name='ChannelType', example='1'),
      createTime?: string(name='CreateTime', example='2019-06-20T17:33Z'),
      createType?: int32(name='CreateType', example='0'),
      dataSetType?: int32(name='DataSetType', example='3'),
      isDelete?: int32(name='IsDelete', example='0'),
      roleConfigProp?: string(name='RoleConfigProp', example='filesFromLocal/ef7ff45c147a4a5e882c925f9a75ac43'),
      roleConfigStatus?: int32(name='RoleConfigStatus', example='1'),
      roleConfigTask?: string(name='RoleConfigTask', example='xx'),
      setBucketName?: string(name='SetBucketName', example='“”'),
      setDomain?: string(name='SetDomain', example='“”'),
      setFolderName?: string(name='SetFolderName', example='“”'),
      setId?: long(name='SetId', example='1'),
      setName?: string(name='SetName'),
      setNumber?: int32(name='SetNumber', example='1'),
      setRoleArn?: string(name='SetRoleArn', example='“”'),
      setType?: int32(name='SetType', example='1'),
      sourceDataType?: int32(name='SourceDataType', example='11'),
      subDir?: string(name='SubDir', example='xx'),
      updateTime?: string(name='UpdateTime', example='2022-05-10T10:34Z'),
      userGroup?: string(name='UserGroup', example='1'),
    }
  ](name='Data')
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='96138D8D-8D26-4E41-BFF4-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
}

model ListDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListDataSetResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI ListDataSet is deprecated
 *
 * @summary 获取数据集列表
 *
 * @param request ListDataSetRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListDataSetResponse
 */
// Deprecated
async function listDataSetWithOptions(request: ListDataSetRequest, runtime: Util.RuntimeOptions): ListDataSetResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListDataSet',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI ListDataSet is deprecated
 *
 * @summary 获取数据集列表
 *
 * @param request ListDataSetRequest
 * @return ListDataSetResponse
 */
// Deprecated
async function listDataSet(request: ListDataSetRequest): ListDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  return listDataSetWithOptions(request, runtime);
}

model ListPrecisionTaskRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='"{"pageSize":10,"pageNumber":1}"'),
}

model ListPrecisionTaskResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='22'),
  data?: {
    precisionTask?: [ 
    {
      createTime?: string(name='CreateTime', example='2020-03-10 20:26:29'),
      dataSetId?: long(name='DataSetId', example='1212'),
      dataSetName?: string(name='DataSetName'),
      duration?: int32(name='Duration', example='331311'),
      incorrectWords?: int32(name='IncorrectWords', example='32'),
      name?: string(name='Name'),
      precisions?: {
        precision?: [ 
        {
          createTime?: string(name='CreateTime', example='2020-03-10 20:26:29'),
          modelId?: long(name='ModelId', example='2321'),
          modelName?: string(name='ModelName'),
          precision?: float(name='Precision', example='0.98'),
          status?: int32(name='Status', example='1'),
          taskId?: string(name='TaskId', example='7C1DEF5F-2C18-4D36-99C6-8C276F781796'),
        }
      ](name='Precision')
      }(name='Precisions'),
      source?: int32(name='Source', example='3'),
      status?: int32(name='Status', example='1'),
      taskId?: string(name='TaskId', example='7C1DEF5F-2C18-4D36-99C6-8C276F781796'),
      totalCount?: int32(name='TotalCount', example='21'),
      updateTime?: string(name='UpdateTime', example='2020-03-10 20:26:29'),
      verifiedCount?: int32(name='VerifiedCount', example='3'),
    }
  ](name='PrecisionTask')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model ListPrecisionTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListPrecisionTaskResponseBody(name='body'),
}

/**
 * @param request ListPrecisionTaskRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListPrecisionTaskResponse
 */
async function listPrecisionTaskWithOptions(request: ListPrecisionTaskRequest, runtime: Util.RuntimeOptions): ListPrecisionTaskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListPrecisionTask',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListPrecisionTaskRequest
 * @return ListPrecisionTaskResponse
 */
async function listPrecisionTask(request: ListPrecisionTaskRequest): ListPrecisionTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPrecisionTaskWithOptions(request, runtime);
}

model ListQualityCheckSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model ListQualityCheckSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='22'),
  data?: [ 
    {
      createTime?: string(name='CreateTime', example='2022-05-10T09:34Z'),
      createUserName?: string(name='CreateUserName'),
      dataType?: int32(name='DataType', example='1'),
      description?: string(name='Description'),
      name?: string(name='Name', example='test'),
      ruleList?: [ 
        {
          rules?: [ 
            {
              checkType?: int32(name='CheckType', example='1'),
              name?: string(name='Name'),
              rid?: long(name='Rid', example='12'),
              ruleScoreType?: int32(name='RuleScoreType', example='1'),
              scoreNum?: int32(name='ScoreNum', example='2'),
              scoreNumType?: int32(name='ScoreNumType', example='0'),
              scoreType?: int32(name='ScoreType', example='1'),
              targetType?: int32(name='TargetType', example='10'),
            }
          ](name='Rules'),
        }
      ](name='RuleList'),
      schemeCheckTypeList?: [ 
        {
          checkName?: string(name='CheckName'),
          checkType?: int32(name='CheckType', example='1'),
          enable?: int32(name='Enable', example='1'),
          score?: int32(name='Score', example='20'),
          targetType?: int32(name='TargetType', example='10'),
        }
      ](name='SchemeCheckTypeList'),
      schemeId?: long(name='SchemeId', example='112**'),
      status?: int32(name='Status', example='1'),
      templateType?: int32(name='TemplateType', example='1'),
      type?: int32(name='Type', example='1'),
      updateTime?: string(name='UpdateTime', example='2022-05-10T10:34Z'),
      updateUserName?: string(name='UpdateUserName'),
      version?: long(name='Version', example='1'),
    }
  ](name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4***'),
  resultCountId?: string(name='ResultCountId', example='XXX'),
  success?: boolean(name='Success', example='true'),
}

model ListQualityCheckSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListQualityCheckSchemeResponseBody(name='body'),
}

/**
 * @summary 质检方案列表
 *
 * @param request ListQualityCheckSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListQualityCheckSchemeResponse
 */
async function listQualityCheckSchemeWithOptions(request: ListQualityCheckSchemeRequest, runtime: Util.RuntimeOptions): ListQualityCheckSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListQualityCheckScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 质检方案列表
 *
 * @param request ListQualityCheckSchemeRequest
 * @return ListQualityCheckSchemeResponse
 */
async function listQualityCheckScheme(request: ListQualityCheckSchemeRequest): ListQualityCheckSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return listQualityCheckSchemeWithOptions(request, runtime);
}

model ListRulesRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10}'),
}

model ListRulesResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='20'),
  data?: [ 
    {
      businessCategoryNameList?: [ string ](name='BusinessCategoryNameList'),
      comments?: string(name='Comments'),
      createTime?: string(name='CreateTime', example='2020-04-20T20:10Z'),
      name?: string(name='Name'),
      rid?: long(name='Rid', example='1234567'),
      ruleType?: int32(name='RuleType', example='1'),
      type?: int32(name='Type', example='1'),
      typeName?: string(name='TypeName'),
    }
  ](name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F**'),
  success?: boolean(name='Success', example='true'),
}

model ListRulesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListRulesResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI ListRules is deprecated, please use Qualitycheck::2019-01-15::ListRulesV4 instead.
 *
 * @param request ListRulesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListRulesResponse
 */
// Deprecated
async function listRulesWithOptions(request: ListRulesRequest, runtime: Util.RuntimeOptions): ListRulesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListRules',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI ListRules is deprecated, please use Qualitycheck::2019-01-15::ListRulesV4 instead.
 *
 * @param request ListRulesRequest
 * @return ListRulesResponse
 */
// Deprecated
async function listRules(request: ListRulesRequest): ListRulesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listRulesWithOptions(request, runtime);
}

model ListRulesV4Request {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  businessName?: string(name='BusinessName'),
  businessRange?: int32(name='BusinessRange'),
  categoryName?: string(name='CategoryName'),
  countTotal?: boolean(name='CountTotal', example='false'),
  createEmpid?: string(name='CreateEmpid', example='1'),
  createUserId?: long(name='CreateUserId', example='1'),
  currentPage?: int32(name='CurrentPage', example='1'),
  endTime?: string(name='EndTime', example='2021-11-29 19:11:09'),
  lastUpdateEmpid?: string(name='LastUpdateEmpid', example='1'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requireInfos?: [ string ](name='RequireInfos'),
  rid?: long(name='Rid', example='895EAD5312634F5AA708E3B3FA79662E'),
  ruleIdOrRuleName?: string(name='RuleIdOrRuleName', example='xx'),
  ruleScoreSingleType?: int32(name='RuleScoreSingleType', example='1'),
  ruleType?: int32(name='RuleType', example='1'),
  schemeId?: long(name='SchemeId', example='1000000090'),
  sourceType?: int32(name='SourceType', example='0'),
  startTime?: string(name='StartTime', example='2021-11-29 18:11:09'),
  status?: int32(name='Status', example='2'),
  type?: int32(name='Type', example='1'),
  typeName?: string(name='TypeName'),
  updateEndTime?: string(name='UpdateEndTime', example='2021-11-29 18:11:09'),
  updateStartTime?: string(name='UpdateStartTime', example='2021-11-29 16:11:09'),
  updateUserId?: long(name='UpdateUserId', example='1'),
}

model ListRulesV4ResponseBody = {
  businessType?: int32(name='BusinessType'),
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='219'),
  currentPage?: int32(name='CurrentPage', example='10'),
  data?: [
    RuleCountInfo
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: [ string ](name='Messages'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='96138D8D-8D26-4E41-BFF4-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
  totalCount?: int32(name='TotalCount', example='219'),
}

model ListRulesV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListRulesV4ResponseBody(name='body'),
}

/**
 * @summary V4获得规则列表
 *
 * @param request ListRulesV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListRulesV4Response
 */
async function listRulesV4WithOptions(request: ListRulesV4Request, runtime: Util.RuntimeOptions): ListRulesV4Response {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.businessName)) {
    body['BusinessName'] = request.businessName;
  }
  if (!Util.isUnset(request.businessRange)) {
    body['BusinessRange'] = request.businessRange;
  }
  if (!Util.isUnset(request.categoryName)) {
    body['CategoryName'] = request.categoryName;
  }
  if (!Util.isUnset(request.countTotal)) {
    body['CountTotal'] = request.countTotal;
  }
  if (!Util.isUnset(request.createEmpid)) {
    body['CreateEmpid'] = request.createEmpid;
  }
  if (!Util.isUnset(request.createUserId)) {
    body['CreateUserId'] = request.createUserId;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endTime)) {
    body['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.lastUpdateEmpid)) {
    body['LastUpdateEmpid'] = request.lastUpdateEmpid;
  }
  if (!Util.isUnset(request.pageNumber)) {
    body['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.requireInfos)) {
    body['RequireInfos'] = request.requireInfos;
  }
  if (!Util.isUnset(request.rid)) {
    body['Rid'] = request.rid;
  }
  if (!Util.isUnset(request.ruleIdOrRuleName)) {
    body['RuleIdOrRuleName'] = request.ruleIdOrRuleName;
  }
  if (!Util.isUnset(request.ruleScoreSingleType)) {
    body['RuleScoreSingleType'] = request.ruleScoreSingleType;
  }
  if (!Util.isUnset(request.ruleType)) {
    body['RuleType'] = request.ruleType;
  }
  if (!Util.isUnset(request.schemeId)) {
    body['SchemeId'] = request.schemeId;
  }
  if (!Util.isUnset(request.sourceType)) {
    body['SourceType'] = request.sourceType;
  }
  if (!Util.isUnset(request.startTime)) {
    body['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.status)) {
    body['Status'] = request.status;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.typeName)) {
    body['TypeName'] = request.typeName;
  }
  if (!Util.isUnset(request.updateEndTime)) {
    body['UpdateEndTime'] = request.updateEndTime;
  }
  if (!Util.isUnset(request.updateStartTime)) {
    body['UpdateStartTime'] = request.updateStartTime;
  }
  if (!Util.isUnset(request.updateUserId)) {
    body['UpdateUserId'] = request.updateUserId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListRulesV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary V4获得规则列表
 *
 * @param request ListRulesV4Request
 * @return ListRulesV4Response
 */
async function listRulesV4(request: ListRulesV4Request): ListRulesV4Response {
  var runtime = new Util.RuntimeOptions{};
  return listRulesV4WithOptions(request, runtime);
}

model ListSchemeTaskConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"pageNumber":1,"pageSize":10,"sourceDataType":"1"}'),
}

model ListSchemeTaskConfigResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='22'),
  currentPage?: int32(name='CurrentPage', example='1'),
  data?: {
    data?: [ 
    {
      asrTaskPriority?: int32(name='AsrTaskPriority', example='2'),
      asrVersion?: int32(name='AsrVersion'),
      assignType?: int32(name='AssignType', example='0'),
      createTime?: string(name='CreateTime', example='1650418039000'),
      createUser?: long(name='CreateUser', example='1'),
      dataConfig?: {
        assignConfigs?: {
          assignConfig?: [ 
          {
            assignConfigContests?: {
              assignConfigContest?: [ 
              {
                dataType?: int32(name='DataType', example='3'),
                listObject?: {
                  listObject?: [ any ](name='ListObject')
                }(name='ListObject'),
                name?: string(name='Name', example='callStartTime'),
                symbol?: int32(name='Symbol', example='4'),
                value?: string(name='Value', example='{\\\\"start\\\\":\\\\"2022-09-01 00:00:00\\\\",\\\\"end\\\\":\\\\"2022-09-30 00:00:00\\\\"}'),
              }
            ](name='AssignConfigContest')
            }(name='AssignConfigContests'),
          }
        ](name='AssignConfig')
        }(name='AssignConfigs'),
        dataSets?: string(name='DataSets', example='[]'),
        index?: int32(name='Index', example='0'),
        resultParam?: string(name='ResultParam', example='{}'),
      }(name='DataConfig'),
      finishRate?: double(name='FinishRate', example='100'),
      id?: long(name='Id', example='123'),
      manualReview?: int32(name='ManualReview', example='0'),
      modeCustomizationId?: string(name='ModeCustomizationId', example='cdae396590b*****ec40f3476e274fc'),
      modelName?: string(name='ModelName'),
      name?: string(name='Name'),
      numberExecuting?: int32(name='NumberExecuting', example='0'),
      numberFail?: int32(name='NumberFail', example='0'),
      numberSuccess?: int32(name='NumberSuccess', example='1000'),
      numberSum?: int32(name='NumberSum', example='1000'),
      schemeIdList?: {
        schemeIdList?: [ long ](name='SchemeIdList')
      }(name='SchemeIdList'),
      schemeList?: {
        schemeList?: [ 
        {
          name?: string(name='Name'),
          schemeId?: long(name='SchemeId', example='158'),
        }
      ](name='SchemeList')
      }(name='SchemeList'),
      schemeTaskConfigId?: long(name='SchemeTaskConfigId', example='123'),
      sourceDataType?: int32(name='SourceDataType', example='2'),
      status?: int32(name='Status', example='1'),
      type?: int32(name='Type', example='0'),
      updateTime?: string(name='UpdateTime', example='1650418039000'),
      updateUser?: long(name='UpdateUser', example='1'),
      userGroup?: string(name='UserGroup', example='1'),
      vocabId?: string(name='VocabId', example='9f90b3efa2****0a49acec226eafc17'),
      vocabName?: string(name='VocabName'),
    }
  ](name='Data')
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  lastDataId?: string(name='LastDataId', example='xxx'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='4B0A8DCD-0DDF-5E80-8B9C-0A2F68B3403B'),
  resultCountId?: string(name='ResultCountId'),
  success?: boolean(name='Success', example='true'),
}

model ListSchemeTaskConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSchemeTaskConfigResponseBody(name='body'),
}

/**
 * @summary 获取质检任务列表
 *
 * @param request ListSchemeTaskConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSchemeTaskConfigResponse
 */
async function listSchemeTaskConfigWithOptions(request: ListSchemeTaskConfigRequest, runtime: Util.RuntimeOptions): ListSchemeTaskConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSchemeTaskConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 获取质检任务列表
 *
 * @param request ListSchemeTaskConfigRequest
 * @return ListSchemeTaskConfigResponse
 */
async function listSchemeTaskConfig(request: ListSchemeTaskConfigRequest): ListSchemeTaskConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSchemeTaskConfigWithOptions(request, runtime);
}

model ListSessionGroupRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"isSchemeData":1,"pageNumber":1,"pageSize":10,"callStartTime":"2022-09-17 00:00:00","callEndTime":"2022-09-23 23:59:59","schemeTaskConfigId":368}'),
}

model ListSessionGroupResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='2228'),
  currentPage?: int32(name='CurrentPage', example='1'),
  data?: {
    data?: [ 
    {
      assignStatus?: int32(name='AssignStatus', example='1'),
      callStartTime?: string(name='CallStartTime', example='2022-09-26 10:09:14'),
      callerList?: {
        callerList?: [ string ](name='CallerList')
      }(name='CallerList'),
      customerIdList?: {
        customerIdList?: [ string ](name='CustomerIdList')
      }(name='CustomerIdList'),
      customerNameList?: {
        customerNameList?: [ string ](name='CustomerNameList')
      }(name='CustomerNameList'),
      customerServiceIdList?: {
        customerServiceIdList?: [ string ](name='CustomerServiceIdList')
      }(name='CustomerServiceIdList'),
      customerServiceNameList?: {
        customerServiceNameList?: [ string ](name='CustomerServiceNameList')
      }(name='CustomerServiceNameList'),
      hitSessionCount?: int32(name='HitSessionCount', example='1'),
      lastDataId?: string(name='LastDataId', example='4498420@a_z@93EAADF1-01D3-44BD-8AC9-F57F447EFCE8_1614*****'),
      reviewStatus?: int32(name='ReviewStatus', example='1'),
      reviewerList?: {
        reviewerList?: [ string ](name='ReviewerList')
      }(name='ReviewerList'),
      schemeTaskConfigId?: long(name='SchemeTaskConfigId', example='123'),
      schemeTaskConfigName?: string(name='SchemeTaskConfigName'),
      score?: long(name='Score', example='100'),
      sessionCount?: int32(name='SessionCount', example='1'),
      sessionGroupId?: string(name='SessionGroupId', example='SessionGroupA'),
      sessionGroupReviewedOrComplained?: boolean(name='SessionGroupReviewedOrComplained', example='true'),
      skillGroupNameList?: {
        skillGroupNameList?: [ string ](name='SkillGroupNameList')
      }(name='SkillGroupNameList'),
    }
  ](name='Data')
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  lastDataId?: string(name='LastDataId', example='xxx'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  resultCountId?: string(name='ResultCountId'),
  success?: boolean(name='Success', example='true'),
}

model ListSessionGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSessionGroupResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI ListSessionGroup is deprecated
 *
 * @summary 获取会话组列表
 *
 * @param request ListSessionGroupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSessionGroupResponse
 */
// Deprecated
async function listSessionGroupWithOptions(request: ListSessionGroupRequest, runtime: Util.RuntimeOptions): ListSessionGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSessionGroup',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI ListSessionGroup is deprecated
 *
 * @summary 获取会话组列表
 *
 * @param request ListSessionGroupRequest
 * @return ListSessionGroupResponse
 */
// Deprecated
async function listSessionGroup(request: ListSessionGroupRequest): ListSessionGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSessionGroupWithOptions(request, runtime);
}

model ListSkillGroupConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize": 1}'),
}

model ListSkillGroupConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    skillGroupConfig?: [ 
    {
      allContentQualityCheck?: int32(name='AllContentQualityCheck', example='1'),
      allRids?: string(name='AllRids', example='223'),
      allRuleList?: {
        ruleNameInfo?: [ 
        {
          rid?: long(name='Rid', example='221'),
          ruleName?: string(name='RuleName', example='test'),
        }
      ](name='RuleNameInfo')
      }(name='AllRuleList'),
      createTime?: string(name='CreateTime', example='2020-12-01T15:12Z'),
      id?: long(name='Id', example='221'),
      instanceId?: string(name='InstanceId', example='xxx'),
      modelId?: long(name='ModelId', example='211'),
      modelName?: string(name='ModelName', example='xxx'),
      name?: string(name='Name', example='xxx'),
      qualityCheckType?: int32(name='QualityCheckType', example='0'),
      rid?: string(name='Rid', example='2221'),
      ruleList?: {
        ruleNameInfo?: [ 
        {
          rid?: long(name='Rid', example='2221'),
          ruleName?: string(name='RuleName', example='x\\\\"x\\\\"x'),
        }
      ](name='RuleNameInfo')
      }(name='RuleList'),
      screenSwitch?: boolean(name='ScreenSwitch', example='true'),
      skillGroupFrom?: int32(name='SkillGroupFrom', example='0'),
      skillGroupId?: string(name='SkillGroupId', example='123'),
      skillGroupName?: string(name='SkillGroupName', example='xxx'),
      skillGroupScreens?: {
        skillGroupScreen?: [ 
        {
          dataType?: int32(name='DataType', example='0'),
          name?: string(name='Name', example='customerName'),
          symbol?: int32(name='Symbol', example='1'),
          value?: string(name='Value'),
        }
      ](name='SkillGroupScreen')
      }(name='SkillGroupScreens'),
      status?: int32(name='Status', example='1'),
      type?: int32(name='Type', example='1'),
      updateTime?: string(name='UpdateTime', example='2020-12-01T19:28Z'),
      vocabId?: long(name='VocabId', example='323'),
      vocabName?: string(name='VocabName', example='xxx'),
    }
  ](name='SkillGroupConfig')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='3CEA0495-341B-4482-9AD9-8191EF4***'),
  success?: boolean(name='Success', example='true'),
}

model ListSkillGroupConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSkillGroupConfigResponseBody(name='body'),
}

/**
 * @param request ListSkillGroupConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSkillGroupConfigResponse
 */
async function listSkillGroupConfigWithOptions(request: ListSkillGroupConfigRequest, runtime: Util.RuntimeOptions): ListSkillGroupConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSkillGroupConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListSkillGroupConfigRequest
 * @return ListSkillGroupConfigResponse
 */
async function listSkillGroupConfig(request: ListSkillGroupConfigRequest): ListSkillGroupConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSkillGroupConfigWithOptions(request, runtime);
}

model ListTaskAssignRulesRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10}'),
}

model ListTaskAssignRulesResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='23'),
  data?: {
    taskAssignRuleInfo?: [ 
    {
      agents?: {
        agent?: [ 
        {
          agentId?: string(name='AgentId', example='202526561358712105'),
          agentName?: string(name='AgentName', example='agent'),
        }
      ](name='Agent')
      }(name='Agents'),
      agentsStr?: string(name='AgentsStr', example='XX'),
      assignmentType?: int32(name='AssignmentType', example='0'),
      callTimeEnd?: long(name='CallTimeEnd', example='39600'),
      callTimeStart?: long(name='CallTimeStart', example='39600'),
      callType?: int32(name='CallType', example='1'),
      createTime?: string(name='CreateTime', example='2019-07-12T14:47Z'),
      durationMax?: int32(name='DurationMax', example='400'),
      durationMin?: int32(name='DurationMin', example='100'),
      enabled?: int32(name='Enabled', example='1'),
      priority?: int32(name='Priority', example='1'),
      reviewers?: {
        reviewer?: [ 
        {
          reviewerId?: string(name='ReviewerId', example='2337235457340978'),
          reviewerName?: string(name='ReviewerName'),
        }
      ](name='Reviewer')
      }(name='Reviewers'),
      ruleId?: long(name='RuleId', example='23'),
      ruleName?: string(name='RuleName'),
      rules?: {
        ruleBasicInfo?: [ 
        {
          name?: string(name='Name'),
          rid?: string(name='Rid', example='2312'),
        }
      ](name='RuleBasicInfo')
      }(name='Rules'),
      samplingMode?: {
        anyNumberOfDraws?: int32(name='AnyNumberOfDraws', example='60'),
        designated?: boolean(name='Designated', example='true'),
        dimension?: int32(name='Dimension', example='0'),
        limit?: int32(name='Limit', example='30'),
        numberOfDraws?: int32(name='NumberOfDraws', example='20'),
        proportion?: float(name='Proportion', example='0.1'),
        randomInspectionNumber?: int32(name='RandomInspectionNumber', example='5'),
        samplingModeAgents?: {
          samplingModeAgent?: [ 
          {
            agentId?: string(name='AgentId', example='123'),
            agentName?: string(name='AgentName', example='zhangsan'),
          }
        ](name='SamplingModeAgent')
        }(name='SamplingModeAgents'),
      }(name='SamplingMode'),
      skillGroups?: {
        skillGroup?: [ 
        {
          skillId?: string(name='SkillId', example='XXX'),
          skillName?: string(name='SkillName'),
        }
      ](name='SkillGroup')
      }(name='SkillGroups'),
      skillGroupsStr?: string(name='SkillGroupsStr', example='XX'),
      updateTime?: string(name='UpdateTime', example='2019-07-12T14:47Z'),
    }
  ](name='TaskAssignRuleInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model ListTaskAssignRulesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListTaskAssignRulesResponseBody(name='body'),
}

/**
 * @param request ListTaskAssignRulesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListTaskAssignRulesResponse
 */
async function listTaskAssignRulesWithOptions(request: ListTaskAssignRulesRequest, runtime: Util.RuntimeOptions): ListTaskAssignRulesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListTaskAssignRules',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListTaskAssignRulesRequest
 * @return ListTaskAssignRulesResponse
 */
async function listTaskAssignRules(request: ListTaskAssignRulesRequest): ListTaskAssignRulesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listTaskAssignRulesWithOptions(request, runtime);
}

model ListUsersRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10}'),
}

model ListUsersResponseBody = {
  code?: string(name='Code', example='200'),
  count?: int32(name='Count', example='12'),
  data?: {
    user?: [ 
    {
      aliUid?: string(name='AliUid', example='2951869706989****'),
      createTime?: string(name='CreateTime', example='2020-03-11T16:54Z'),
      description?: string(name='Description', example='XXX'),
      displayName?: string(name='DisplayName', example='xxx'),
      id?: long(name='Id', example='1'),
      loginUserType?: int32(name='LoginUserType', example='2'),
      roleName?: string(name='RoleName', example='AGENT'),
      updateTime?: string(name='UpdateTime', example='2020-03-11T16:54Z'),
      userName?: string(name='UserName', example='xxx'),
    }
  ](name='User')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model ListUsersResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListUsersResponseBody(name='body'),
}

/**
 * @param request ListUsersRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListUsersResponse
 */
async function listUsersWithOptions(request: ListUsersRequest, runtime: Util.RuntimeOptions): ListUsersResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListUsers',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListUsersRequest
 * @return ListUsersResponse
 */
async function listUsers(request: ListUsersRequest): ListUsersResponse {
  var runtime = new Util.RuntimeOptions{};
  return listUsersWithOptions(request, runtime);
}

model ListWarningConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"pageNumber":1,"pageSize":10}'),
}

model ListWarningConfigResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    warningConfigInfo?: [ 
    {
      channels?: {
        channel?: [ 
        {
          type?: int32(name='Type', example='0'),
          url?: string(name='Url', example='oapi.dingtalk.com/robot/send?access_token=c55628f700eb9ad2a3ca'),
        }
      ](name='Channel')
      }(name='Channels'),
      configId?: long(name='ConfigId', example='32'),
      configName?: string(name='ConfigName'),
      createTime?: string(name='CreateTime', example='2019-10-29T15:30Z'),
      ridList?: {
        ridList?: [ string ](name='RidList')
      }(name='RidList'),
      ruleList?: {
        warningRule?: [ 
        {
          rid?: long(name='Rid', example='33452'),
          ruleName?: string(name='RuleName'),
        }
      ](name='WarningRule')
      }(name='RuleList'),
      status?: int32(name='Status', example='1'),
      updateTime?: string(name='UpdateTime', example='2019-10-29T17:24Z'),
    }
  ](name='WarningConfigInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model ListWarningConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListWarningConfigResponseBody(name='body'),
}

/**
 * @param request ListWarningConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListWarningConfigResponse
 */
async function listWarningConfigWithOptions(request: ListWarningConfigRequest, runtime: Util.RuntimeOptions): ListWarningConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListWarningConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListWarningConfigRequest
 * @return ListWarningConfigResponse
 */
async function listWarningConfig(request: ListWarningConfigRequest): ListWarningConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return listWarningConfigWithOptions(request, runtime);
}

model ListWarningStrategyConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model ListWarningStrategyConfigResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: {
    data?: [ 
    {
      id?: long(name='Id'),
      intervalTime?: long(name='IntervalTime'),
      lambda?: string(name='Lambda'),
      level?: long(name='Level'),
      maxNumber?: long(name='MaxNumber'),
      name?: string(name='Name'),
    }
  ](name='data')
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListWarningStrategyConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListWarningStrategyConfigResponseBody(name='body'),
}

/**
 * @summary  预警策略-列表
 *
 * @param request ListWarningStrategyConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListWarningStrategyConfigResponse
 */
async function listWarningStrategyConfigWithOptions(request: ListWarningStrategyConfigRequest, runtime: Util.RuntimeOptions): ListWarningStrategyConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListWarningStrategyConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary  预警策略-列表
 *
 * @param request ListWarningStrategyConfigRequest
 * @return ListWarningStrategyConfigResponse
 */
async function listWarningStrategyConfig(request: ListWarningStrategyConfigRequest): ListWarningStrategyConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return listWarningStrategyConfigWithOptions(request, runtime);
}

model RevertAssignedSessionRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"isSchemeData":1,"searchParam":{"schemeTaskConfigId":1,"sourceDataType":1,"startTime":"2022-09-20 00:00:00","endTime":"2022-09-26 23:59:59"}}'),
}

model RevertAssignedSessionResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model RevertAssignedSessionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RevertAssignedSessionResponseBody(name='body'),
}

/**
 * @summary 批量回收
 *
 * @param request RevertAssignedSessionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RevertAssignedSessionResponse
 */
async function revertAssignedSessionWithOptions(request: RevertAssignedSessionRequest, runtime: Util.RuntimeOptions): RevertAssignedSessionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RevertAssignedSession',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 批量回收
 *
 * @param request RevertAssignedSessionRequest
 * @return RevertAssignedSessionResponse
 */
async function revertAssignedSession(request: RevertAssignedSessionRequest): RevertAssignedSessionResponse {
  var runtime = new Util.RuntimeOptions{};
  return revertAssignedSessionWithOptions(request, runtime);
}

model RevertAssignedSessionGroupRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"isSchemeData":1,"forceRevertSessionGroup":true,"sessionGroupIdList":["1"]}'),
}

model RevertAssignedSessionGroupResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model RevertAssignedSessionGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RevertAssignedSessionGroupResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI RevertAssignedSessionGroup is deprecated
 *
 * @summary 会话组批量回收
 *
 * @param request RevertAssignedSessionGroupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RevertAssignedSessionGroupResponse
 */
// Deprecated
async function revertAssignedSessionGroupWithOptions(request: RevertAssignedSessionGroupRequest, runtime: Util.RuntimeOptions): RevertAssignedSessionGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RevertAssignedSessionGroup',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI RevertAssignedSessionGroup is deprecated
 *
 * @summary 会话组批量回收
 *
 * @param request RevertAssignedSessionGroupRequest
 * @return RevertAssignedSessionGroupResponse
 */
// Deprecated
async function revertAssignedSessionGroup(request: RevertAssignedSessionGroupRequest): RevertAssignedSessionGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return revertAssignedSessionGroupWithOptions(request, runtime);
}

model SaveConfigDataSetRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model SaveConfigDataSetResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success', example='true'),
}

model SaveConfigDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SaveConfigDataSetResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI SaveConfigDataSet is deprecated
 *
 * @param request SaveConfigDataSetRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SaveConfigDataSetResponse
 */
// Deprecated
async function saveConfigDataSetWithOptions(request: SaveConfigDataSetRequest, runtime: Util.RuntimeOptions): SaveConfigDataSetResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveConfigDataSet',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI SaveConfigDataSet is deprecated
 *
 * @param request SaveConfigDataSetRequest
 * @return SaveConfigDataSetResponse
 */
// Deprecated
async function saveConfigDataSet(request: SaveConfigDataSetRequest): SaveConfigDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveConfigDataSetWithOptions(request, runtime);
}

model SubmitComplaintRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model SubmitComplaintResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='90'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model SubmitComplaintResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitComplaintResponseBody(name='body'),
}

/**
 * @param request SubmitComplaintRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitComplaintResponse
 */
async function submitComplaintWithOptions(request: SubmitComplaintRequest, runtime: Util.RuntimeOptions): SubmitComplaintResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SubmitComplaint',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SubmitComplaintRequest
 * @return SubmitComplaintResponse
 */
async function submitComplaint(request: SubmitComplaintRequest): SubmitComplaintResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitComplaintWithOptions(request, runtime);
}

model SubmitPrecisionTaskRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='"{"name":"test","dataSetId":1865}"'),
}

model SubmitPrecisionTaskResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='EA701F66-8CA2-4A79-8E3C-A6F2FA****'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model SubmitPrecisionTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitPrecisionTaskResponseBody(name='body'),
}

/**
 * @param request SubmitPrecisionTaskRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitPrecisionTaskResponse
 */
async function submitPrecisionTaskWithOptions(request: SubmitPrecisionTaskRequest, runtime: Util.RuntimeOptions): SubmitPrecisionTaskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SubmitPrecisionTask',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SubmitPrecisionTaskRequest
 * @return SubmitPrecisionTaskResponse
 */
async function submitPrecisionTask(request: SubmitPrecisionTaskRequest): SubmitPrecisionTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitPrecisionTaskWithOptions(request, runtime);
}

model SubmitQualityCheckTaskRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model SubmitQualityCheckTaskResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='F6C2B68F-2311-4495-82AC-DAE86C9****'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', example='00A044A2-D59B-4104-96BA-84060AE8345F'),
  success?: boolean(name='Success', example='true'),
}

model SubmitQualityCheckTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitQualityCheckTaskResponseBody(name='body'),
}

/**
 * @param request SubmitQualityCheckTaskRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitQualityCheckTaskResponse
 */
async function submitQualityCheckTaskWithOptions(request: SubmitQualityCheckTaskRequest, runtime: Util.RuntimeOptions): SubmitQualityCheckTaskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SubmitQualityCheckTask',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SubmitQualityCheckTaskRequest
 * @return SubmitQualityCheckTaskResponse
 */
async function submitQualityCheckTask(request: SubmitQualityCheckTaskRequest): SubmitQualityCheckTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitQualityCheckTaskWithOptions(request, runtime);
}

model SubmitReviewInfoRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model SubmitReviewInfoResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='95'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model SubmitReviewInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitReviewInfoResponseBody(name='body'),
}

/**
 * @param request SubmitReviewInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitReviewInfoResponse
 */
async function submitReviewInfoWithOptions(request: SubmitReviewInfoRequest, runtime: Util.RuntimeOptions): SubmitReviewInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SubmitReviewInfo',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SubmitReviewInfoRequest
 * @return SubmitReviewInfoResponse
 */
async function submitReviewInfo(request: SubmitReviewInfoRequest): SubmitReviewInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitReviewInfoWithOptions(request, runtime);
}

model SyncQualityCheckRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"tid":"20200823-234234","dialogue":"{}"}'),
}

model SyncQualityCheckResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    beginTime?: long(name='BeginTime', example='1584535485856'),
    rules?: [ 
      {
        hit?: [ 
          {
            hitKeyWords?: [ 
              {
                cid?: int32(name='Cid', example='2312'),
                from?: int32(name='From', example='1'),
                pid?: int32(name='Pid', example='4'),
                to?: int32(name='To', example='4'),
                val?: string(name='Val'),
              }
            ](name='HitKeyWords'),
            phrase?: {
              begin?: long(name='Begin', example='1230'),
              emotionValue?: int32(name='EmotionValue', example='6'),
              end?: long(name='End', example='3440'),
              identity?: string(name='Identity', example='xxx'),
              role?: string(name='Role'),
              silenceDuration?: int32(name='SilenceDuration', example='123'),
              speechRate?: int32(name='SpeechRate', example='233'),
              words?: string(name='Words'),
            }(name='Phrase'),
          }
        ](name='Hit'),
        rid?: string(name='Rid', example='232232'),
        ruleInfoBase?: {
          comments?: string(name='Comments'),
          level?: int32(name='Level'),
          ruleCategoryName?: string(name='RuleCategoryName'),
          scoreNum?: int32(name='ScoreNum'),
          scoreNumType?: int32(name='ScoreNumType'),
          scoreType?: int32(name='ScoreType'),
          type?: int32(name='Type'),
        }(name='RuleInfoBase'),
        ruleName?: string(name='RuleName'),
      }
    ](name='Rules'),
    score?: int32(name='Score', example='100'),
    taskId?: string(name='TaskId', example='66E1ACB866E1ACB8'),
    tid?: string(name='Tid', example='20200876-66E1ACB8'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='66E1ACB8-17B2-4BE8-8581-954A8*****'),
  success?: boolean(name='Success', example='true'),
}

model SyncQualityCheckResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SyncQualityCheckResponseBody(name='body'),
}

/**
 * @param request SyncQualityCheckRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SyncQualityCheckResponse
 */
async function syncQualityCheckWithOptions(request: SyncQualityCheckRequest, runtime: Util.RuntimeOptions): SyncQualityCheckResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SyncQualityCheck',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SyncQualityCheckRequest
 * @return SyncQualityCheckResponse
 */
async function syncQualityCheck(request: SyncQualityCheckRequest): SyncQualityCheckResponse {
  var runtime = new Util.RuntimeOptions{};
  return syncQualityCheckWithOptions(request, runtime);
}

model TestRuleV4Request {
  isSchemeData?: int32(name='IsSchemeData', example='1'),
  testJson?: string(name='TestJson', description='This parameter is required.'),
}

model TestRuleV4ResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    hitRuleReviewInfoList?: [ 
      {
        branchHitId?: long(name='BranchHitId', example='1'),
        branchInfoList?: [ 
          {
            checkType?: int32(name='CheckType', example='0'),
            index?: int32(name='Index', example='1'),
            lambda?: string(name='Lambda', example='a&&b'),
            name?: string(name='Name'),
            nextNodeId?: long(name='NextNodeId', example='2'),
            situation?: NextNodeSituations(name='Situation'),
            triggers?: [ string ](name='Triggers'),
          }
        ](name='BranchInfoList'),
        conditionHitInfoList?: [ 
          {
            cid?: [ string ](name='Cid'),
            keyWords?: [ 
              {
                cid?: string(name='Cid', example='4'),
                customizeCode?: string(name='CustomizeCode'),
                from?: int32(name='From', example='1'),
                oid?: string(name='Oid', example='123'),
                operatorKey?: string(name='OperatorKey'),
                pid?: int32(name='Pid', example='13'),
                similarPhrase?: string(name='SimilarPhrase'),
                tid?: string(name='Tid'),
                to?: int32(name='To', example='3'),
                uuid?: string(name='Uuid'),
                val?: string(name='Val'),
              }
            ](name='KeyWords'),
            phrase?: {
              begin?: long(name='Begin', example='72000'),
              beginTime?: string(name='BeginTime', example='2019-11-25 15:37:16'),
              channelId?: int32(name='ChannelId', example='0'),
              emotionFineGrainedValue?: int32(name='EmotionFineGrainedValue'),
              emotionValue?: int32(name='EmotionValue', example='7'),
              end?: long(name='End', example='80000'),
              hitStatus?: int32(name='HitStatus', example='1'),
              hourMinSec?: string(name='HourMinSec', example='10:00:00'),
              identity?: string(name='Identity'),
              pid?: int32(name='Pid', example='3'),
              renterId?: long(name='RenterId'),
              role?: string(name='Role'),
              sid?: long(name='Sid'),
              silenceDuration?: int32(name='SilenceDuration', example='1000'),
              speechRate?: int32(name='SpeechRate', example='100'),
              uuid?: string(name='Uuid'),
              words?: string(name='Words'),
            }(name='Phrase'),
          }
        ](name='ConditionHitInfoList'),
        conditionInfoList?: [
          ConditionBasicInfo
        ](name='ConditionInfoList'),
        judgeNodeName?: string(name='JudgeNodeName'),
        lambda?: string(name='Lambda', example='a&&b'),
        matched?: boolean(name='Matched', example='true'),
        nodeType?: string(name='NodeType', example='0'),
        rid?: long(name='Rid', example='451'),
        ruleName?: string(name='RuleName'),
        ruleScoreType?: int32(name='RuleScoreType', example='1'),
        scoreNumType?: int32(name='ScoreNumType', example='1'),
        taskFlowId?: long(name='TaskFlowId', example='1'),
      }
    ](name='HitRuleReviewInfoList'),
    hitTaskFlowList?: [ 
      {
        graphFlow?: TaskGraphFlow(name='GraphFlow'),
        rid?: long(name='Rid', example='1'),
        taskFlowType?: int32(name='TaskFlowType'),
      }
    ](name='HitTaskFlowList'),
    unhitRuleReviewInfoList?: [ 
      {
        conditionInfoList?: [
          ConditionBasicInfo
        ](name='ConditionInfoList'),
        matched?: boolean(name='Matched', example='true'),
        rid?: long(name='Rid', example='2'),
        taskFlowType?: int32(name='TaskFlowType'),
      }
    ](name='UnhitRuleReviewInfoList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='96138D8D-XXXX-4E41-XXXX-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
}

model TestRuleV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: TestRuleV4ResponseBody(name='body'),
}

/**
 * @summary 测试规则
 *
 * @param request TestRuleV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return TestRuleV4Response
 */
async function testRuleV4WithOptions(request: TestRuleV4Request, runtime: Util.RuntimeOptions): TestRuleV4Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.isSchemeData)) {
    body['IsSchemeData'] = request.isSchemeData;
  }
  if (!Util.isUnset(request.testJson)) {
    body['TestJson'] = request.testJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TestRuleV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 测试规则
 *
 * @param request TestRuleV4Request
 * @return TestRuleV4Response
 */
async function testRuleV4(request: TestRuleV4Request): TestRuleV4Response {
  var runtime = new Util.RuntimeOptions{};
  return testRuleV4WithOptions(request, runtime);
}

model UpdateAsrVocabRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model UpdateAsrVocabResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='71b1795ac8634bd8bdf4d3878480c7c2'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model UpdateAsrVocabResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAsrVocabResponseBody(name='body'),
}

/**
 * @param request UpdateAsrVocabRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateAsrVocabResponse
 */
async function updateAsrVocabWithOptions(request: UpdateAsrVocabRequest, runtime: Util.RuntimeOptions): UpdateAsrVocabResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAsrVocab',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateAsrVocabRequest
 * @return UpdateAsrVocabResponse
 */
async function updateAsrVocab(request: UpdateAsrVocabRequest): UpdateAsrVocabResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAsrVocabWithOptions(request, runtime);
}

model UpdateCheckTypeToSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr'),
}

model UpdateCheckTypeToSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='4'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='F190ADE9-619A-447D-84E3-7E241A5C428E'),
  success?: boolean(name='Success', example='true'),
}

model UpdateCheckTypeToSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateCheckTypeToSchemeResponseBody(name='body'),
}

/**
 * @summary 更新质检方案中的质检维度
 *
 * @param request UpdateCheckTypeToSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateCheckTypeToSchemeResponse
 */
async function updateCheckTypeToSchemeWithOptions(request: UpdateCheckTypeToSchemeRequest, runtime: Util.RuntimeOptions): UpdateCheckTypeToSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateCheckTypeToScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更新质检方案中的质检维度
 *
 * @param request UpdateCheckTypeToSchemeRequest
 * @return UpdateCheckTypeToSchemeResponse
 */
async function updateCheckTypeToScheme(request: UpdateCheckTypeToSchemeRequest): UpdateCheckTypeToSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateCheckTypeToSchemeWithOptions(request, runtime);
}

model UpdateQualityCheckDataRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"taskId":"xxx"}'),
}

model UpdateQualityCheckDataResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='xxx'),
  success?: boolean(name='Success', example='true'),
}

model UpdateQualityCheckDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateQualityCheckDataResponseBody(name='body'),
}

/**
 * @summary 更新会话随录数据
 *
 * @param request UpdateQualityCheckDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateQualityCheckDataResponse
 */
async function updateQualityCheckDataWithOptions(request: UpdateQualityCheckDataRequest, runtime: Util.RuntimeOptions): UpdateQualityCheckDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateQualityCheckData',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更新会话随录数据
 *
 * @param request UpdateQualityCheckDataRequest
 * @return UpdateQualityCheckDataResponse
 */
async function updateQualityCheckData(request: UpdateQualityCheckDataRequest): UpdateQualityCheckDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateQualityCheckDataWithOptions(request, runtime);
}

model UpdateQualityCheckSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr'),
}

model UpdateQualityCheckSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='96138D8D-8D26-4E41-BFF4-77AED1088BBD'),
  success?: boolean(name='Success', example='true'),
}

model UpdateQualityCheckSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateQualityCheckSchemeResponseBody(name='body'),
}

/**
 * @summary 更新质检方案
 *
 * @param request UpdateQualityCheckSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateQualityCheckSchemeResponse
 */
async function updateQualityCheckSchemeWithOptions(request: UpdateQualityCheckSchemeRequest, runtime: Util.RuntimeOptions): UpdateQualityCheckSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateQualityCheckScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更新质检方案
 *
 * @param request UpdateQualityCheckSchemeRequest
 * @return UpdateQualityCheckSchemeResponse
 */
async function updateQualityCheckScheme(request: UpdateQualityCheckSchemeRequest): UpdateQualityCheckSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateQualityCheckSchemeWithOptions(request, runtime);
}

model UpdateRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model UpdateRuleResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='xxx'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model UpdateRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateRuleResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI UpdateRule is deprecated, please use Qualitycheck::2019-01-15::UpdateRuleV4 instead.
 *
 * @param request UpdateRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateRuleResponse
 */
// Deprecated
async function updateRuleWithOptions(request: UpdateRuleRequest, runtime: Util.RuntimeOptions): UpdateRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI UpdateRule is deprecated, please use Qualitycheck::2019-01-15::UpdateRuleV4 instead.
 *
 * @param request UpdateRuleRequest
 * @return UpdateRuleResponse
 */
// Deprecated
async function updateRule(request: UpdateRuleRequest): UpdateRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateRuleWithOptions(request, runtime);
}

model UpdateRuleByIdRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  isCopy?: boolean(name='IsCopy', example='false'),
  jsonStrForRule?: string(name='JsonStrForRule', description='This parameter is required.', example='{}'),
  returnRelatedSchemes?: boolean(name='ReturnRelatedSchemes', example='1'),
  ruleId?: long(name='RuleId', example='1'),
}

model UpdateRuleByIdResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='82C91484-B2D5-4D2A-A21F-A6D73F4D55C6'),
  success?: boolean(name='Success', example='true'),
}

model UpdateRuleByIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateRuleByIdResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI UpdateRuleById is deprecated, please use Qualitycheck::2019-01-15::UpdateRuleV4 instead.
 *
 * @summary 更新规则
 *
 * @param request UpdateRuleByIdRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateRuleByIdResponse
 */
// Deprecated
async function updateRuleByIdWithOptions(request: UpdateRuleByIdRequest, runtime: Util.RuntimeOptions): UpdateRuleByIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.isCopy)) {
    body['IsCopy'] = request.isCopy;
  }
  if (!Util.isUnset(request.jsonStrForRule)) {
    body['JsonStrForRule'] = request.jsonStrForRule;
  }
  if (!Util.isUnset(request.returnRelatedSchemes)) {
    body['ReturnRelatedSchemes'] = request.returnRelatedSchemes;
  }
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRuleById',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI UpdateRuleById is deprecated, please use Qualitycheck::2019-01-15::UpdateRuleV4 instead.
 *
 * @summary 更新规则
 *
 * @param request UpdateRuleByIdRequest
 * @return UpdateRuleByIdResponse
 */
// Deprecated
async function updateRuleById(request: UpdateRuleByIdRequest): UpdateRuleByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateRuleByIdWithOptions(request, runtime);
}

model UpdateRuleToSchemeRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr', example='{"schemeId":"10","schemeRules":[{"ruleId":229,"checkType":0}]}'),
}

model UpdateRuleToSchemeResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='30'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='9987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model UpdateRuleToSchemeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateRuleToSchemeResponseBody(name='body'),
}

/**
 * @summary 更新质检方案的规则
 *
 * @param request UpdateRuleToSchemeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateRuleToSchemeResponse
 */
async function updateRuleToSchemeWithOptions(request: UpdateRuleToSchemeRequest, runtime: Util.RuntimeOptions): UpdateRuleToSchemeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRuleToScheme',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更新质检方案的规则
 *
 * @param request UpdateRuleToSchemeRequest
 * @return UpdateRuleToSchemeResponse
 */
async function updateRuleToScheme(request: UpdateRuleToSchemeRequest): UpdateRuleToSchemeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateRuleToSchemeWithOptions(request, runtime);
}

model UpdateRuleV4Request {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStrForRule?: string(name='JsonStrForRule', description='This parameter is required.'),
  ruleId?: long(name='RuleId', example='1'),
}

model UpdateRuleV4ResponseBody = {
  code?: string(name='Code', example='200'),
  data?: long(name='Data', example='1'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model UpdateRuleV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateRuleV4ResponseBody(name='body'),
}

/**
 * @summary V4更新规则
 *
 * @param request UpdateRuleV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateRuleV4Response
 */
async function updateRuleV4WithOptions(request: UpdateRuleV4Request, runtime: Util.RuntimeOptions): UpdateRuleV4Response {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.jsonStrForRule)) {
    body['JsonStrForRule'] = request.jsonStrForRule;
  }
  if (!Util.isUnset(request.ruleId)) {
    body['RuleId'] = request.ruleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRuleV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary V4更新规则
 *
 * @param request UpdateRuleV4Request
 * @return UpdateRuleV4Response
 */
async function updateRuleV4(request: UpdateRuleV4Request): UpdateRuleV4Response {
  var runtime = new Util.RuntimeOptions{};
  return updateRuleV4WithOptions(request, runtime);
}

model UpdateSchemeTaskConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='jsonStr'),
}

model UpdateSchemeTaskConfigResponseBody = {
  code?: string(name='Code', example='200'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='successful'),
  messages?: {
    message?: [ string ](name='Message')
  }(name='Messages'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24***'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSchemeTaskConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSchemeTaskConfigResponseBody(name='body'),
}

/**
 * @summary 更新质检任务
 *
 * @param request UpdateSchemeTaskConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSchemeTaskConfigResponse
 */
async function updateSchemeTaskConfigWithOptions(request: UpdateSchemeTaskConfigRequest, runtime: Util.RuntimeOptions): UpdateSchemeTaskConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['jsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSchemeTaskConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更新质检任务
 *
 * @param request UpdateSchemeTaskConfigRequest
 * @return UpdateSchemeTaskConfigResponse
 */
async function updateSchemeTaskConfig(request: UpdateSchemeTaskConfigRequest): UpdateSchemeTaskConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSchemeTaskConfigWithOptions(request, runtime);
}

model UpdateSkillGroupConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"skillGroupFrom":0,"name":"test","qualityCheckType":0,"rid":"2493,4098","vocabId":267,"skillGroupList":[{"skillGroupId":"090311","skillGroupName":"09031"}],"id":553}'),
}

model UpdateSkillGroupConfigResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='38E7E948-0876-4FEE-B0AA-6*****'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSkillGroupConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSkillGroupConfigResponseBody(name='body'),
}

/**
 * @param request UpdateSkillGroupConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSkillGroupConfigResponse
 */
async function updateSkillGroupConfigWithOptions(request: UpdateSkillGroupConfigRequest, runtime: Util.RuntimeOptions): UpdateSkillGroupConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSkillGroupConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateSkillGroupConfigRequest
 * @return UpdateSkillGroupConfigResponse
 */
async function updateSkillGroupConfig(request: UpdateSkillGroupConfigRequest): UpdateSkillGroupConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSkillGroupConfigWithOptions(request, runtime);
}

model UpdateSyncQualityCheckDataRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"tid":"xxx"}'),
}

model UpdateSyncQualityCheckDataResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    taskId?: string(name='TaskId', example='123123D8C-5BD9-42A7-B527-1235F8**'),
    tid?: string(name='Tid', example='20210101-1212121***'),
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='76DB5D8C-5BD9-42A7-B527-5AF3A5F8***'),
  success?: boolean(name='Success', example='true'),
}

model UpdateSyncQualityCheckDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSyncQualityCheckDataResponseBody(name='body'),
}

/**
 * @param request UpdateSyncQualityCheckDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateSyncQualityCheckDataResponse
 */
async function updateSyncQualityCheckDataWithOptions(request: UpdateSyncQualityCheckDataRequest, runtime: Util.RuntimeOptions): UpdateSyncQualityCheckDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSyncQualityCheckData',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateSyncQualityCheckDataRequest
 * @return UpdateSyncQualityCheckDataResponse
 */
async function updateSyncQualityCheckData(request: UpdateSyncQualityCheckDataRequest): UpdateSyncQualityCheckDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSyncQualityCheckDataWithOptions(request, runtime);
}

model UpdateTaskAssignRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model UpdateTaskAssignRuleResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model UpdateTaskAssignRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateTaskAssignRuleResponseBody(name='body'),
}

/**
 * @param request UpdateTaskAssignRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateTaskAssignRuleResponse
 */
async function updateTaskAssignRuleWithOptions(request: UpdateTaskAssignRuleRequest, runtime: Util.RuntimeOptions): UpdateTaskAssignRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateTaskAssignRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateTaskAssignRuleRequest
 * @return UpdateTaskAssignRuleResponse
 */
async function updateTaskAssignRule(request: UpdateTaskAssignRuleRequest): UpdateTaskAssignRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateTaskAssignRuleWithOptions(request, runtime);
}

model UpdateUserRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='[{"aliUid":"2951869706989****","roleName":"ADMIN"},{"aliUid":"2557461687048****","roleName":"ADMIN"}]'),
}

model UpdateUserResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model UpdateUserResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateUserResponseBody(name='body'),
}

/**
 * @param request UpdateUserRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateUserResponse
 */
async function updateUserWithOptions(request: UpdateUserRequest, runtime: Util.RuntimeOptions): UpdateUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateUser',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateUserRequest
 * @return UpdateUserResponse
 */
async function updateUser(request: UpdateUserRequest): UpdateUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateUserWithOptions(request, runtime);
}

model UpdateWarningConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"ridList":[18130],"configName":"0310","channels":[{"type":1,"url":"https://sca.console.aliyun.com/#/warningConfig"}],"configId":29}'),
}

model UpdateWarningConfigResponseBody = {
  code?: string(name='Code', example='200'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model UpdateWarningConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateWarningConfigResponseBody(name='body'),
}

/**
 * @param request UpdateWarningConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateWarningConfigResponse
 */
async function updateWarningConfigWithOptions(request: UpdateWarningConfigRequest, runtime: Util.RuntimeOptions): UpdateWarningConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateWarningConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpdateWarningConfigRequest
 * @return UpdateWarningConfigResponse
 */
async function updateWarningConfig(request: UpdateWarningConfigRequest): UpdateWarningConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWarningConfigWithOptions(request, runtime);
}

model UpdateWarningStrategyConfigRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model UpdateWarningStrategyConfigResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateWarningStrategyConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateWarningStrategyConfigResponseBody(name='body'),
}

/**
 * @summary  预警策略-更新
 *
 * @param request UpdateWarningStrategyConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpdateWarningStrategyConfigResponse
 */
async function updateWarningStrategyConfigWithOptions(request: UpdateWarningStrategyConfigRequest, runtime: Util.RuntimeOptions): UpdateWarningStrategyConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateWarningStrategyConfig',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary  预警策略-更新
 *
 * @param request UpdateWarningStrategyConfigRequest
 * @return UpdateWarningStrategyConfigResponse
 */
async function updateWarningStrategyConfig(request: UpdateWarningStrategyConfigRequest): UpdateWarningStrategyConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWarningStrategyConfigWithOptions(request, runtime);
}

model UploadAudioDataRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', example='123456'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{“callList”:“xxxxx”}'),
}

model UploadAudioDataResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='76DB5D8C-5BD9-42A7-B527-5AF3A5***'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='76DB5D8C-5BD9-42A7-B527-5AF3A5F8***'),
  success?: boolean(name='Success', example='true'),
}

model UploadAudioDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadAudioDataResponseBody(name='body'),
}

/**
 * @param request UploadAudioDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadAudioDataResponse
 */
async function uploadAudioDataWithOptions(request: UploadAudioDataRequest, runtime: Util.RuntimeOptions): UploadAudioDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadAudioData',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UploadAudioDataRequest
 * @return UploadAudioDataResponse
 */
async function uploadAudioData(request: UploadAudioDataRequest): UploadAudioDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadAudioDataWithOptions(request, runtime);
}

model UploadDataRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='xxx'),
}

model UploadDataResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='6F5934C7-C223-4F0F-BBF3-5B3594***'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='6F5934C7-C223-4F0F-BBF3-5B3594****'),
  success?: boolean(name='Success', example='true'),
}

model UploadDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadDataResponseBody(name='body'),
}

/**
 * @deprecated OpenAPI UploadData is deprecated, please use Qualitycheck::2019-01-15::UploadDataV4 instead.
 *
 * @summary 推荐使用UploadDataV4接口,支持更长的JsonStr,但仅支持POST方法.
 *
 * @param request UploadDataRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadDataResponse
 */
// Deprecated
async function uploadDataWithOptions(request: UploadDataRequest, runtime: Util.RuntimeOptions): UploadDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadData',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @deprecated OpenAPI UploadData is deprecated, please use Qualitycheck::2019-01-15::UploadDataV4 instead.
 *
 * @summary 推荐使用UploadDataV4接口,支持更长的JsonStr,但仅支持POST方法.
 *
 * @param request UploadDataRequest
 * @return UploadDataResponse
 */
// Deprecated
async function uploadData(request: UploadDataRequest): UploadDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadDataWithOptions(request, runtime);
}

model UploadDataSyncRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{"tickets":xxx}'),
}

model UploadDataSyncResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    resultInfo?: [ 
    {
      handScoreIdList?: {
        handScoreIdList?: [ string ](name='HandScoreIdList')
      }(name='HandScoreIdList'),
      rules?: {
        ruleHitInfo?: [ 
        {
          conditionInfo?: {
            conditionBasicInfo?: [ 
            {
              conditionInfoCid?: string(name='ConditionInfoCid', example='xxx'),
            }
          ](name='ConditionBasicInfo')
          }(name='ConditionInfo'),
          hit?: {
            conditionHitInfo?: [ 
            {
              hitCids?: {
                cidItem?: [ string ](name='CidItem')
              }(name='HitCids'),
              hitKeyWords?: {
                hitKeyWord?: [ 
                {
                  from?: int32(name='From', example='1'),
                  pid?: int32(name='Pid', example='1'),
                  tid?: string(name='Tid', example='1'),
                  to?: int32(name='To', example='1'),
                  val?: string(name='Val'),
                }
              ](name='HitKeyWord')
              }(name='HitKeyWords'),
              phrase?: {
                begin?: long(name='Begin', example='0'),
                beginTime?: string(name='BeginTime', example='1564574'),
                end?: long(name='End', example='2090'),
                identity?: string(name='Identity', example='1'),
                role?: string(name='Role'),
                words?: string(name='Words'),
              }(name='Phrase'),
            }
          ](name='ConditionHitInfo')
          }(name='Hit'),
          rid?: string(name='Rid', example='801'),
          tid?: string(name='Tid', example='88888888'),
        }
      ](name='RuleHitInfo')
      }(name='Rules'),
      score?: int32(name='Score', example='100'),
    }
  ](name='ResultInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B***'),
  success?: boolean(name='Success', example='true'),
}

model UploadDataSyncResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadDataSyncResponseBody(name='body'),
}

/**
 * @summary http_hsf
 *
 * @param request UploadDataSyncRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadDataSyncResponse
 */
async function uploadDataSyncWithOptions(request: UploadDataSyncRequest, runtime: Util.RuntimeOptions): UploadDataSyncResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadDataSync',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary http_hsf
 *
 * @param request UploadDataSyncRequest
 * @return UploadDataSyncResponse
 */
async function uploadDataSync(request: UploadDataSyncRequest): UploadDataSyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadDataSyncWithOptions(request, runtime);
}

model UploadDataSyncForLLMRequest {
  baseMeAgentId?: long(name='BaseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model UploadDataSyncForLLMResponseBody = {
  code?: string(name='Code'),
  data?: {
    resultInfo?: [ 
    {
      rules?: {
        ruleHitInfo?: [ 
        {
          conditionInfo?: {
            conditionBasicInfo?: [ 
            {
              conditionInfoCid?: string(name='ConditionInfoCid'),
            }
          ](name='ConditionBasicInfo')
          }(name='ConditionInfo'),
          hit?: {
            conditionHitInfo?: [ 
            {
              hitCids?: {
                cidItem?: [ string ](name='CidItem')
              }(name='HitCids'),
              hitKeyWords?: {
                hitKeyWord?: [ 
                {
                  from?: int32(name='From'),
                  pid?: int32(name='Pid'),
                  tid?: string(name='Tid'),
                  to?: int32(name='To'),
                  val?: string(name='Val'),
                }
              ](name='HitKeyWord')
              }(name='HitKeyWords'),
              phrase?: {
                begin?: long(name='Begin'),
                beginTime?: string(name='BeginTime'),
                end?: long(name='End'),
                identity?: string(name='Identity'),
                role?: string(name='Role'),
                words?: string(name='Words'),
              }(name='Phrase'),
            }
          ](name='ConditionHitInfo')
          }(name='Hit'),
          rid?: string(name='Rid'),
          tid?: string(name='Tid'),
        }
      ](name='RuleHitInfo')
      }(name='Rules'),
      score?: int32(name='Score'),
    }
  ](name='ResultInfo')
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UploadDataSyncForLLMResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadDataSyncForLLMResponseBody(name='body'),
}

/**
 * @summary http_hsf
 *
 * @param request UploadDataSyncForLLMRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadDataSyncForLLMResponse
 */
async function uploadDataSyncForLLMWithOptions(request: UploadDataSyncForLLMRequest, runtime: Util.RuntimeOptions): UploadDataSyncForLLMResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadDataSyncForLLM',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary http_hsf
 *
 * @param request UploadDataSyncForLLMRequest
 * @return UploadDataSyncForLLMResponse
 */
async function uploadDataSyncForLLM(request: UploadDataSyncForLLMRequest): UploadDataSyncForLLMResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadDataSyncForLLMWithOptions(request, runtime);
}

model UploadDataV4Request {
  baseMeAgentId?: long(name='BaseMeAgentId', example='123456'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='xxx'),
}

model UploadDataV4ResponseBody = {
  code?: string(name='Code', example='200'),
  data?: string(name='Data', example='6F5934C7-C223-4F0F-BBF3-5B3594***'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='6F5934C7-C223-4F0F-BBF3-5B3594***'),
  success?: boolean(name='Success', example='true'),
}

model UploadDataV4Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadDataV4ResponseBody(name='body'),
}

/**
 * @summary UploadDataV4
 *
 * @param request UploadDataV4Request
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadDataV4Response
 */
async function uploadDataV4WithOptions(request: UploadDataV4Request, runtime: Util.RuntimeOptions): UploadDataV4Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    body['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    body['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UploadDataV4',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary UploadDataV4
 *
 * @param request UploadDataV4Request
 * @return UploadDataV4Response
 */
async function uploadDataV4(request: UploadDataV4Request): UploadDataV4Response {
  var runtime = new Util.RuntimeOptions{};
  return uploadDataV4WithOptions(request, runtime);
}

model UploadRuleRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.', example='{“conditions”:“xxxxx”,"rules":"xxxx"}'),
}

model UploadRuleResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    ridInfo?: [ string ](name='RidInfo')
  }(name='Data'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='4987D326-83D9-4A42-B9A5-0B27F9B40539'),
  success?: boolean(name='Success', example='true'),
}

model UploadRuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadRuleResponseBody(name='body'),
}

/**
 * @param request UploadRuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UploadRuleResponse
 */
async function uploadRuleWithOptions(request: UploadRuleRequest, runtime: Util.RuntimeOptions): UploadRuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadRule',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UploadRuleRequest
 * @return UploadRuleResponse
 */
async function uploadRule(request: UploadRuleRequest): UploadRuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadRuleWithOptions(request, runtime);
}

model VerifyFileRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model VerifyFileResponseBody = {
  code?: string(name='Code', example='200'),
  data?: float(name='Data', example='0.9485294'),
  message?: string(name='Message', example='s'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  success?: boolean(name='Success', example='true'),
}

model VerifyFileResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifyFileResponseBody(name='body'),
}

/**
 * @param request VerifyFileRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return VerifyFileResponse
 */
async function verifyFileWithOptions(request: VerifyFileRequest, runtime: Util.RuntimeOptions): VerifyFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifyFile',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request VerifyFileRequest
 * @return VerifyFileResponse
 */
async function verifyFile(request: VerifyFileRequest): VerifyFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyFileWithOptions(request, runtime);
}

model VerifySentenceRequest {
  baseMeAgentId?: long(name='BaseMeAgentId', description='baseMeAgentId'),
  jsonStr?: string(name='JsonStr', description='This parameter is required.'),
}

model VerifySentenceResponseBody = {
  code?: string(name='Code', example='200'),
  data?: {
    delta?: [ 
    {
      source?: {
        line?: {
          line?: [ string ](name='Line')
        }(name='Line'),
        position?: int32(name='Position', example='1'),
      }(name='Source'),
      target?: {
        line?: {
          line?: [ string ](name='Line')
        }(name='Line'),
        position?: int32(name='Position', example='1'),
      }(name='Target'),
      type?: string(name='Type', example='CHANGE'),
    }
  ](name='Delta')
  }(name='Data'),
  incorrectWords?: int32(name='IncorrectWords', example='2'),
  message?: string(name='Message', example='successful'),
  requestId?: string(name='RequestId', example='106C6CA0-282D-4AF7-85F0-D2D24F4CE647'),
  sourceRole?: int32(name='SourceRole', example='0'),
  success?: boolean(name='Success', example='true'),
  targetRole?: int32(name='TargetRole', example='1'),
}

model VerifySentenceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifySentenceResponseBody(name='body'),
}

/**
 * @param request VerifySentenceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return VerifySentenceResponse
 */
async function verifySentenceWithOptions(request: VerifySentenceRequest, runtime: Util.RuntimeOptions): VerifySentenceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.baseMeAgentId)) {
    query['BaseMeAgentId'] = request.baseMeAgentId;
  }
  if (!Util.isUnset(request.jsonStr)) {
    query['JsonStr'] = request.jsonStr;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifySentence',
    version = '2019-01-15',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request VerifySentenceRequest
 * @return VerifySentenceResponse
 */
async function verifySentence(request: VerifySentenceRequest): VerifySentenceResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifySentenceWithOptions(request, runtime);
}

